# studio_wrapper.py

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

g_cmd_tree_hash = '83e1bfb3a13bb970193903fd8c156725'
g_compiler_version = '1.0'

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


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 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 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 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 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 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 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 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 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 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 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 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 RootCoreOrtPropertyInput_select(wrap.CmdTreeProp):

    class EnumType(Enum):
        Fast_In_Deflection = 'Fast In Deflection'
        Hi_Res_In_Deflection = 'Hi Res In Deflection'
        Fast_In_User = 'Fast In User'
        Hi_Res_In_User1 = 'Hi Res In User1'

    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('str')

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

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

    @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 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 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_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 RootCoreOrtProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property'
        self.baseline_window_end = RootCoreOrtPropertyBaseline_window_end(self._context)
        self.baseline_frequency = RootCoreOrtPropertyBaseline_frequency(self._context)
        self.feedback_amplitude_position = RootCoreOrtPropertyFeedback_amplitude_position(self._context)
        self.input_select = RootCoreOrtPropertyInput_select(self._context)
        self.cantilever_samples_per_period = RootCoreOrtPropertyCantilever_samples_per_period(self._context)
        self.free_wave_delay = RootCoreOrtPropertyFree_wave_delay(self._context)
        self.samples_per_period = RootCoreOrtPropertySamples_per_period(self._context)
        self.excitation_enabled = RootCoreOrtPropertyExcitation_enabled(self._context)
        self.adhesion_position = RootCoreOrtPropertyAdhesion_position(self._context)
        self.baseline_controller_enabled = RootCoreOrtPropertyBaseline_controller_enabled(self._context)
        self.adhesion_value = RootCoreOrtPropertyAdhesion_value(self._context)
        self.baseline_window_begin = RootCoreOrtPropertyBaseline_window_begin(self._context)
        self.baseline_amplitude = RootCoreOrtPropertyBaseline_amplitude(self._context)
        self.average_periods = RootCoreOrtPropertyAverage_periods(self._context)
        self.baseline_value = RootCoreOrtPropertyBaseline_value(self._context)
        self.amplitude_reduction = RootCoreOrtPropertyAmplitude_reduction(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 update_free_wave(self, *args) -> Any:
        return self._context.call('root.core.ort.update_free_wave', *args)

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

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

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

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

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


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


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 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_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_tunePropertyMeasurement_environment(wrap.CmdTreeProp):

    class EnumType(Enum):
        Air = 'Air'
        Liquid = 'Liquid'

    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('str')

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

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

    @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_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_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_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_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_tuneProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property'
        self.resolution = RootCoreThermal_tunePropertyResolution(self._context)
        self.fit_frequency_upper_bound = RootCoreThermal_tunePropertyFit_frequency_upper_bound(self._context)
        self.fit_frequency_lower_bound = RootCoreThermal_tunePropertyFit_frequency_lower_bound(self._context)
        self.iterations = RootCoreThermal_tunePropertyIterations(self._context)
        self.measurement_environment = RootCoreThermal_tunePropertyMeasurement_environment(self._context)
        self.max_frequency = RootCoreThermal_tunePropertyMax_frequency(self._context)
        self.temperature = RootCoreThermal_tunePropertyTemperature(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_frequency_list.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_fit.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.ended.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.started.connect', *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 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)

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


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_average.connect', *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.new_average = RootCoreThermal_tuneSignalNew_average(self._context)
        self.progress = RootCoreThermal_tuneSignalProgress(self._context)
        self.started = RootCoreThermal_tuneSignalStarted(self._context)
        self.procedure_info = RootCoreThermal_tuneSignalProcedure_info(self._context)
        self.ended = RootCoreThermal_tuneSignalEnded(self._context)
        self.new_fit = RootCoreThermal_tuneSignalNew_fit(self._context)
        self.new_frequency_list = RootCoreThermal_tuneSignalNew_frequency_list(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.signal = RootCoreThermal_tuneSignal(self._context)
        self.property = RootCoreThermal_tuneProperty(self._context)

    def start(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.start', *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 calculate_cantilever_calibration(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.calculate_cantilever_calibration', *args)

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

    def set_fit_window_range(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.set_fit_window_range', *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 auto_calc_properties(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.auto_calc_properties', *args)

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


class RootCoreFrequency_sweepPropertyFrequency_selection_criteria(wrap.CmdTreeProp):

    class EnumType(Enum):
        Below_Peak = 'Below Peak'
        Above_Peak = 'Above Peak'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootCoreFrequency_sweepPropertyFrequency_selection_criteria.EnumType(self._context.get('root.core.frequency_sweep.property.frequency_selection_criteria.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.core.frequency_sweep.property.frequency_selection_criteria.value', new_val.value)

    @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_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_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_sweepPropertyMeasurement_environment(wrap.CmdTreeProp):

    class EnumType(Enum):
        Air = 'Air'
        Liquid = 'Liquid'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootCoreFrequency_sweepPropertyMeasurement_environment.EnumType(self._context.get('root.core.frequency_sweep.property.measurement_environment.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.core.frequency_sweep.property.measurement_environment.value', new_val.value)

    @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_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_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_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_sweepPropertyAmplitude_unit(wrap.CmdTreeProp):

    class EnumType(Enum):
        Meters_m_ = 'Meters [m]'
        Volts_V_ = 'Volts [V]'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootCoreFrequency_sweepPropertyAmplitude_unit.EnumType(self._context.get('root.core.frequency_sweep.property.amplitude_unit.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.core.frequency_sweep.property.amplitude_unit.value', new_val.value)

    @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_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_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_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_sweepPropertyAnalyzer_demodulator_bandwidth(wrap.CmdTreeProp):

    class EnumType(Enum):
        num_90_Hz = '90 Hz'
        num_180_Hz = '180 Hz'
        num_360_Hz = '360 Hz'
        num_750_Hz = '750 Hz'
        num_1500_Hz = '1500 Hz'
        num_3_kHz = '3 kHz'
        num_6_kHz = '6 kHz'
        num_12_kHz = '12 kHz'
        num_23_kHz = '23 kHz'
        num_45_kHz = '45 kHz'
        num_100_kHz = '100 kHz'
        num_230_kHz = '230 kHz'
        num_500_kHz = '500 kHz'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootCoreFrequency_sweepPropertyAnalyzer_demodulator_bandwidth.EnumType(self._context.get('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.value', new_val.value)

    @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_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_sweepProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property'
        self.temperature = RootCoreFrequency_sweepPropertyTemperature(self._context)
        self.analyzer_demodulator_bandwidth = RootCoreFrequency_sweepPropertyAnalyzer_demodulator_bandwidth(self._context)
        self.fit_frequency_lower_bound = RootCoreFrequency_sweepPropertyFit_frequency_lower_bound(self._context)
        self.sweep_free_vibration_amplitude = RootCoreFrequency_sweepPropertySweep_free_vibration_amplitude(self._context)
        self.fit_frequency_upper_bound = RootCoreFrequency_sweepPropertyFit_frequency_upper_bound(self._context)
        self.amplitude_unit = RootCoreFrequency_sweepPropertyAmplitude_unit(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.sweep_data_points = RootCoreFrequency_sweepPropertySweep_data_points(self._context)
        self.amplitude_reduction = RootCoreFrequency_sweepPropertyAmplitude_reduction(self._context)
        self.measurement_environment = RootCoreFrequency_sweepPropertyMeasurement_environment(self._context)
        self.sweep_frequency_lower_bound = RootCoreFrequency_sweepPropertySweep_frequency_lower_bound(self._context)
        self.new_excitation_frequency = RootCoreFrequency_sweepPropertyNew_excitation_frequency(self._context)
        self.new_spring_constant = RootCoreFrequency_sweepPropertyNew_spring_constant(self._context)
        self.frequency_selection_criteria = RootCoreFrequency_sweepPropertyFrequency_selection_criteria(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.process_sweep_data.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_sweep_data.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.data_invalidated.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_ended.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_progress.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_fit_data.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sho_fit_failed.connect', *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.sho_fit_failed = RootCoreFrequency_sweepSignalSho_fit_failed(self._context)
        self.new_fit_data = RootCoreFrequency_sweepSignalNew_fit_data(self._context)
        self.sweep_progress = RootCoreFrequency_sweepSignalSweep_progress(self._context)
        self.sweep_ended = RootCoreFrequency_sweepSignalSweep_ended(self._context)
        self.data_invalidated = RootCoreFrequency_sweepSignalData_invalidated(self._context)
        self.new_sweep_data = RootCoreFrequency_sweepSignalNew_sweep_data(self._context)
        self.process_sweep_data = RootCoreFrequency_sweepSignalProcess_sweep_data(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.signal = RootCoreFrequency_sweepSignal(self._context)
        self.property = RootCoreFrequency_sweepProperty(self._context)

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

    def calculate_spring_constant(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.calculate_spring_constant', *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 do_sho_fit(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.do_sho_fit', *args)

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

    def set_sweep_parameters(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.set_sweep_parameters', *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 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)


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 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 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_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Position_Controlled = 'Position Controlled'
        Not_Controlled = 'Not Controlled'
        Tip_Position_Ignored = 'Tip Position Ignored'

    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('str')

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

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

    @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 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 RootCoreApproachPropertyMotor_source(wrap.CmdTreeProp):

    class EnumType(Enum):
        Internal = 'Internal'
        External = 'External'

    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('str')

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

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

    @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 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 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 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 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 RootCoreApproachPropertyApproach_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Continuous = 'Continuous'
        Step_by_Step = 'Step by Step'

    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('str')

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

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

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


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.approach.signal.approach_or_withdraw_done.connect', *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 RootCoreApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach'
        self.signal = RootCoreApproachSignal(self._context)
        self.property = RootCoreApproachProperty(self._context)

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

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

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


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


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 RootCoreComp_dc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.comp_dc'


class RootCoreSpectroscopyPropertyBackward_modulation_stop_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Is_Less_Than = 'Is Less Than'
        Is_Greater_Than = 'Is Greater Than'

    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('str')

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

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

    @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_pause_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Z_Off = 'Z Off'
        Z_On = 'Z On'

    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('str')

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

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

    @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_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_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 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 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 RootCoreSpectroscopyPropertyForward_modulation_stop_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Is_Less_Than = 'Is Less Than'
        Is_Greater_Than = 'Is Greater Than'

    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('str')

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

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

    @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 RootCoreSpectroscopyPropertyBackward_modulation_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Fixed_Length = 'Fixed Length'
        Stop_by_Value = 'Stop by Value'

    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('str')

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

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

    @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 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 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_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 RootCoreSpectroscopyPropertyForward_pause_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Z_Off = 'Z Off'
        Z_On = 'Z On'

    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('str')

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

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

    @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 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 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 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 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 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 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 RootCoreSpectroscopyPropertyModulation_output(wrap.CmdTreeProp):

    class EnumType(Enum):
        Position_Z = 'Position Z'
        Tip_Voltage = 'Tip Voltage'
        External_Z = 'External Z'

    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('str')

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

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

    @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 RootCoreSpectroscopyPropertySpec_end_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Keep_Last_Z_Position = 'Keep Last Z Position'
        Z_Controller_Active = 'Z-Controller Active'

    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('str')

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

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

    @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 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 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 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 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 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_modulation_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Fixed_Length = 'Fixed Length'
        Stop_by_Value = 'Stop by Value'

    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('str')

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

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

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


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 RootCoreZ_controllerPropertyMax_z_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.max_z_value'
        self._lua_value_type = wrap.LuaType('float')

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

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

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

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


class RootCoreZ_controllerPropertyFeedback_polarity(wrap.CmdTreeProp):

    class EnumType(Enum):
        positive = 'positive'
        negative = 'negative'
        invalid = 'invalid'

    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('str')

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

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

    @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_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_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_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_controllerPropertyFeedback(wrap.CmdTreeProp):

    class EnumType(Enum):
        Deflection = 'Deflection'
        WaveMode_Amplitude_Reduction = 'WaveMode Amplitude Reduction'
        Dynamic_Mode_Amplitude_Reduction = 'Dynamic Mode Amplitude Reduction'

    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('str')

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

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

    @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_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_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_controllerPropertyIdle_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Enable_Z_Controller = 'Enable Z Controller'
        Retract_Tip = 'Retract Tip'
        Keep_Last_Z_Position = 'Keep Last Z Position'
        Absolute_Z_Position = 'Absolute Z Position'

    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('str')

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

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

    @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_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_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_controllerPropertyBase_work_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Control_Z_by_Z_Sensor = 'Control Z by Z-Sensor'
        Drive_Z = 'Drive Z'
        Control_Z_by_Measurement_Mode = 'Control Z by Measurement Mode'

    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('str')

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

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

    @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.d_gain = RootCoreZ_controllerPropertyD_gain(self._context)
        self.setpoint = RootCoreZ_controllerPropertySetpoint(self._context)
        self.idle_mode = RootCoreZ_controllerPropertyIdle_mode(self._context)
        self.p_gain = RootCoreZ_controllerPropertyP_gain(self._context)
        self.actual_tip_position = RootCoreZ_controllerPropertyActual_tip_position(self._context)
        self.feedback = RootCoreZ_controllerPropertyFeedback(self._context)
        self.actual_feedback_value = RootCoreZ_controllerPropertyActual_feedback_value(self._context)
        self.absolute_idle_position = RootCoreZ_controllerPropertyAbsolute_idle_position(self._context)
        self.i_gain = RootCoreZ_controllerPropertyI_gain(self._context)
        self.feedback_polarity = RootCoreZ_controllerPropertyFeedback_polarity(self._context)
        self.max_z_value = RootCoreZ_controllerPropertyMax_z_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 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 tip_position_lower_limit(self, *args) -> Any:
        return self._context.call('root.core.z_controller.tip_position_lower_limit', *args)

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


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


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 RootCoreCore_options(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_options'


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


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_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_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_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_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_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_driveProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property'
        self.relative_tip_position = RootCoreApproach_motors_drivePropertyRelative_tip_position(self._context)
        self.motor_speed = RootCoreApproach_motors_drivePropertyMotor_speed(self._context)
        self.motor_right_position = RootCoreApproach_motors_drivePropertyMotor_right_position(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.motor_speed_advance_retract = RootCoreApproach_motors_drivePropertyMotor_speed_advance_retract(self._context)
        self.motor_speed_approach_motors = RootCoreApproach_motors_drivePropertyMotor_speed_approach_motors(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_started.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_finished.connect', *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_finished = RootCoreApproach_motors_driveSignalMotor_move_finished(self._context)
        self.motor_move_started = RootCoreApproach_motors_driveSignalMotor_move_started(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.signal = RootCoreApproach_motors_driveSignal(self._context)
        self.property = RootCoreApproach_motors_driveProperty(self._context)

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

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

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

    def stop_motors(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.stop_motors', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_search_step_finished.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_finished.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.center_detector_finished.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_finished.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_pte_aligned.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_started.connect', *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.motor_move_started = RootCoreLaser_align_drive_implSignalMotor_move_started(self._context)
        self.auto_align_pte_aligned = RootCoreLaser_align_drive_implSignalAuto_align_pte_aligned(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.center_detector_finished = RootCoreLaser_align_drive_implSignalCenter_detector_finished(self._context)
        self.auto_align_finished = RootCoreLaser_align_drive_implSignalAuto_align_finished(self._context)
        self.auto_align_search_step_finished = RootCoreLaser_align_drive_implSignalAuto_align_search_step_finished(self._context)


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_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_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_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_implPropertyDeflection_offset_calibration_status(wrap.CmdTreeProp):

    class EnumType(Enum):
        No_Error = 'No Error'
        Calibration_Error = 'Calibration Error'
        Sensor_Signal_Failed = 'Sensor Signal Failed'

    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('str')

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

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

    @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_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_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_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_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_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_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_implPropertySensor_status(wrap.CmdTreeProp):

    class EnumType(Enum):
        Undefined = 'Undefined'
        Low = 'Low'
        Ok = 'Ok'
        High = 'High'
        Fail = 'Fail'

    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('str')

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

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

    @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_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_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_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_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_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_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_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_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_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_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_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_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_lateral = RootCoreLaser_align_drive_implPropertyDeflection_lateral(self._context)
        self.motor_laser_focus_z_position = RootCoreLaser_align_drive_implPropertyMotor_laser_focus_z_position(self._context)
        self.motor_laser_readout_x_position = RootCoreLaser_align_drive_implPropertyMotor_laser_readout_x_position(self._context)
        self.motor_laser_photodetector_x_position = RootCoreLaser_align_drive_implPropertyMotor_laser_photodetector_x_position(self._context)
        self.deflection_normal = RootCoreLaser_align_drive_implPropertyDeflection_normal(self._context)
        self.motor_laser_readout_y_position = RootCoreLaser_align_drive_implPropertyMotor_laser_readout_y_position(self._context)
        self.motor_laser_clean_drive_x_position = RootCoreLaser_align_drive_implPropertyMotor_laser_clean_drive_x_position(self._context)
        self.laser_readout_enabled = RootCoreLaser_align_drive_implPropertyLaser_readout_enabled(self._context)
        self.motor_speed_max_laser_motors = RootCoreLaser_align_drive_implPropertyMotor_speed_max_laser_motors(self._context)
        self.laser_spot_intensity = RootCoreLaser_align_drive_implPropertyLaser_spot_intensity(self._context)
        self.scan_mode = RootCoreLaser_align_drive_implPropertyScan_mode(self._context)
        self.sensor_status = RootCoreLaser_align_drive_implPropertySensor_status(self._context)
        self.motor_speed_max_laser_focus = RootCoreLaser_align_drive_implPropertyMotor_speed_max_laser_focus(self._context)
        self.laser_clean_drive_enabled = RootCoreLaser_align_drive_implPropertyLaser_clean_drive_enabled(self._context)
        self.motor_speed_max_beam_shifter = RootCoreLaser_align_drive_implPropertyMotor_speed_max_beam_shifter(self._context)
        self.motor_speed_laser_motors = RootCoreLaser_align_drive_implPropertyMotor_speed_laser_motors(self._context)
        self.motor_laser_photodetector_y_position = RootCoreLaser_align_drive_implPropertyMotor_laser_photodetector_y_position(self._context)
        self.laser_readout_power = RootCoreLaser_align_drive_implPropertyLaser_readout_power(self._context)
        self.deflection_offset_calibration_status = RootCoreLaser_align_drive_implPropertyDeflection_offset_calibration_status(self._context)
        self.laser_clean_drive_amplitude = RootCoreLaser_align_drive_implPropertyLaser_clean_drive_amplitude(self._context)
        self.motor_laser_clean_drive_y_position = RootCoreLaser_align_drive_implPropertyMotor_laser_clean_drive_y_position(self._context)
        self.laser_clean_drive_power = RootCoreLaser_align_drive_implPropertyLaser_clean_drive_power(self._context)
        self.motor_beam_shifter_position = RootCoreLaser_align_drive_implPropertyMotor_beam_shifter_position(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 move_motors_by_step(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.move_motors_by_step', *args)

    def abort_center_detector(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.abort_center_detector', *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 start_optimizing(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.start_optimizing', *args)

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

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

    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_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_updating_detector_status(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.start_updating_detector_status', *args)

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

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

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

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


class RootCore(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core'
        self.laser_align_drive_impl = RootCoreLaser_align_drive_impl(self._context)
        self.approach_motors_drive = RootCoreApproach_motors_drive(self._context)
        self.imaging = RootCoreImaging(self._context)
        self.core_options = RootCoreCore_options(self._context)
        self.core_cantilever = RootCoreCore_cantilever(self._context)
        self.oscilloscope = RootCoreOscilloscope(self._context)
        self.z_controller = RootCoreZ_controller(self._context)
        self.converter_channel_correction = RootCoreConverter_channel_correction(self._context)
        self.position_control = RootCorePosition_control(self._context)
        self.spectroscopy = RootCoreSpectroscopy(self._context)
        self.comp_dc = RootCoreComp_dc(self._context)
        self.scan_head_calibration = RootCoreScan_head_calibration(self._context)
        self.signal_analyzer1 = RootCoreSignal_analyzer1(self._context)
        self.approach = RootCoreApproach(self._context)
        self.acquisition = RootCoreAcquisition(self._context)
        self.signal_store = RootCoreSignal_store(self._context)
        self.frequency_sweep = RootCoreFrequency_sweep(self._context)
        self.thermal_tune = RootCoreThermal_tune(self._context)
        self.hv_amp_control = RootCoreHv_amp_control(self._context)
        self.core_environment = RootCoreCore_environment(self._context)
        self.ort = RootCoreOrt(self._context)
        self.direct_motor_control = RootCoreDirect_motor_control(self._context)
        self.core_monitoring = RootCoreCore_monitoring(self._context)


class RootSeqCxRbanaEventmgrSgleStartmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.startmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.startmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.startmask.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleAborteventmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.aborteventmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.aborteventmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.aborteventmask.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleEventsnapshot(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.eventsnapshot'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.eventsnapshot.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.eventsnapshot.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleStatusAbortevent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.status.abortevent'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.abortevent.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.abortevent.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.abortevent.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.abortevent.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.abortevent.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.abortevent.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleStatusStopevent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.status.stopevent'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.stopevent.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.stopevent.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.stopevent.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.stopevent.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.stopevent.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.stopevent.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.status'
        self.stopevent = RootSeqCxRbanaEventmgrSgleStatusStopevent(self._context)
        self.busy = RootSeqCxRbanaEventmgrSgleStatusBusy(self._context)
        self.abortevent = RootSeqCxRbanaEventmgrSgleStatusAbortevent(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleAndmask0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.andmask0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.andmask0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.andmask0.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleStopeventmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.stopeventmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.stopeventmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.stopeventmask.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleEventvector(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.eventvector'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.eventvector.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.eventvector.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControlSoftevent2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control.softevent2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent2.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControlSoftevent1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control.softevent1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent1.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControlSoftevent0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control.softevent0'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent0.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent0.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent0.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent0.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent0.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControlSoftevent3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control.softevent3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.softevent3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.softevent3.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.start.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.control'
        self.start = RootSeqCxRbanaEventmgrSgleControlStart(self._context)
        self.softevent3 = RootSeqCxRbanaEventmgrSgleControlSoftevent3(self._context)
        self.abort = RootSeqCxRbanaEventmgrSgleControlAbort(self._context)
        self.stop = RootSeqCxRbanaEventmgrSgleControlStop(self._context)
        self.softevent0 = RootSeqCxRbanaEventmgrSgleControlSoftevent0(self._context)
        self.softevent1 = RootSeqCxRbanaEventmgrSgleControlSoftevent1(self._context)
        self.softevent2 = RootSeqCxRbanaEventmgrSgleControlSoftevent2(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgleStopmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle.stopmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.eventmgr.sgle.stopmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.eventmgr.sgle.stopmask.regaddr', int(new_val))


class RootSeqCxRbanaEventmgrSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr.sgle'
        self.stopmask = RootSeqCxRbanaEventmgrSgleStopmask(self._context)
        self.control = RootSeqCxRbanaEventmgrSgleControl(self._context)
        self.eventvector = RootSeqCxRbanaEventmgrSgleEventvector(self._context)
        self.stopeventmask = RootSeqCxRbanaEventmgrSgleStopeventmask(self._context)
        self.andmask0 = RootSeqCxRbanaEventmgrSgleAndmask0(self._context)
        self.status = RootSeqCxRbanaEventmgrSgleStatus(self._context)
        self.eventsnapshot = RootSeqCxRbanaEventmgrSgleEventsnapshot(self._context)
        self.aborteventmask = RootSeqCxRbanaEventmgrSgleAborteventmask(self._context)
        self.startmask = RootSeqCxRbanaEventmgrSgleStartmask(self._context)


class RootSeqCxRbanaEventmgr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.eventmgr'
        self.sgle = RootSeqCxRbanaEventmgrSgle(self._context)


class RootSeqCxRbanaInchannelsdigiSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inchannelsdigi.sgle.control'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inchannelsdigi.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inchannelsdigi.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaInchannelsdigiSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inchannelsdigi.sgle'
        self.control = RootSeqCxRbanaInchannelsdigiSgleControl(self._context)


class RootSeqCxRbanaInchannelsdigi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inchannelsdigi'
        self.sgle = RootSeqCxRbanaInchannelsdigiSgle(self._context)


class RootSeqCxRbanaInfastcommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infastcommon'


class RootSeqCxRbanaInhiresCh10Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch10.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch10.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh10(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch10'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh10Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh10Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh10Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh10Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh10Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh10Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh10Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh10Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh10Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh10Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh10Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh10Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh10Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh10Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh10Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh10Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh10Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh10Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh10Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh10Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh10Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh10Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh10Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh10Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh10Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh9Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch9.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch9.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh9(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch9'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh9Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh9Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh9Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh9Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh9Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh9Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh9Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh9Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh9Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh9Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh9Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh9Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh9Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh9Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh9Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh9Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh9Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh9Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh9Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh9Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh9Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh9Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh9Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh9Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh9Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh11Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch11.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch11.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh11(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch11'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh11Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh11Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh11Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh11Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh11Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh11Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh11Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh11Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh11Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh11Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh11Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh11Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh11Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh11Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh11Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh11Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh11Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh11Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh11Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh11Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh11Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh11Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh11Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh11Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh11Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh12Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch12.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch12.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh12(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch12'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh12Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh12Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh12Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh12Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh12Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh12Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh12Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh12Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh12Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh12Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh12Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh12Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh12Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh12Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh12Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh12Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh12Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh12Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh12Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh12Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh12Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh12Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh12Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh12Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh12Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh3Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch3.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch3.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch3'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh3Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh3Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh3Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh3Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh3Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh3Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh3Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh3Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh3Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh3Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh3Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh3Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh3Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh3Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh3Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh3Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh3Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh3Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh3Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh3Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh3Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh3Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh3Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh3Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh3Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh7Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch7.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch7.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch7'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh7Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh7Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh7Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh7Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh7Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh7Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh7Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh7Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh7Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh7Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh7Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh7Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh7Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh7Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh7Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh7Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh7Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh7Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh7Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh7Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh7Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh7Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh7Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh7Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh7Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh1Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch1.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch1.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch1'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh1Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh1Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh1Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh1Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh1Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh1Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh1Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh1Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh1Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh1Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh1Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh1Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh1Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh1Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh1Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh1Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh1Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh1Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh1Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh1Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh1Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh1Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh1Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh1Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh1Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh5Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch5.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch5.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch5'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh5Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh5Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh5Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh5Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh5Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh5Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh5Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh5Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh5Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh5Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh5Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh5Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh5Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh5Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh5Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh5Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh5Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh5Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh5Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh5Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh5Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh5Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh5Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh5Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh5Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh8Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch8.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch8.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh8(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch8'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh8Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh8Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh8Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh8Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh8Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh8Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh8Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh8Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh8Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh8Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh8Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh8Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh8Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh8Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh8Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh8Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh8Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh8Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh8Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh8Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh8Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh8Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh8Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh8Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh8Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh6Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch6.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch6.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch6'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh6Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh6Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh6Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh6Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh6Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh6Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh6Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh6Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh6Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh6Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh6Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh6Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh6Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh6Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh6Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh6Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh6Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh6Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh6Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh6Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh6Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh6Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh6Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh6Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh6Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh2Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch2.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch2.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch2'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh2Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh2Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh2Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh2Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh2Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh2Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh2Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh2Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh2Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh2Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh2Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh2Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh2Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh2Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh2Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh2Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh2Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh2Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh2Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh2Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh2Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh2Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh2Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh2Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh2Cccoefy4(self._context)


class RootSeqCxRbanaInhiresCh4Cccoefy4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefy4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefy4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefy4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefs2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefs2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefs2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefs2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefz3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefz3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefz3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefz3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefz4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefz4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefz4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefz4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefs1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefs1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefs1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefs1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefs4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefs4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefs4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefs4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.filterval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.gain.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.offset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefs3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefs3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefs3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefs3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.inputoffset.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefs0.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefy3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefy3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefy3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefy3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefx4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefx4'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefx4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefx4.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefx3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefx3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefx3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefx3.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhires.ch4.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhires.ch4.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInhiresCh4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires.ch4'
        self.cccoefx1 = RootSeqCxRbanaInhiresCh4Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInhiresCh4Cccoefy1(self._context)
        self.cccoefx3 = RootSeqCxRbanaInhiresCh4Cccoefx3(self._context)
        self.cccoefx4 = RootSeqCxRbanaInhiresCh4Cccoefx4(self._context)
        self.cccoefy3 = RootSeqCxRbanaInhiresCh4Cccoefy3(self._context)
        self.cccoefz1 = RootSeqCxRbanaInhiresCh4Cccoefz1(self._context)
        self.cccoefs0 = RootSeqCxRbanaInhiresCh4Cccoefs0(self._context)
        self.currentinval = RootSeqCxRbanaInhiresCh4Currentinval(self._context)
        self.inputoffset = RootSeqCxRbanaInhiresCh4Inputoffset(self._context)
        self.cccoefs3 = RootSeqCxRbanaInhiresCh4Cccoefs3(self._context)
        self.offset = RootSeqCxRbanaInhiresCh4Offset(self._context)
        self.cccoefy2 = RootSeqCxRbanaInhiresCh4Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInhiresCh4Cccoefy0(self._context)
        self.gain = RootSeqCxRbanaInhiresCh4Gain(self._context)
        self.filterval = RootSeqCxRbanaInhiresCh4Filterval(self._context)
        self.cccoefs4 = RootSeqCxRbanaInhiresCh4Cccoefs4(self._context)
        self.cccoefs1 = RootSeqCxRbanaInhiresCh4Cccoefs1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInhiresCh4Cccoefx2(self._context)
        self.cccoefz4 = RootSeqCxRbanaInhiresCh4Cccoefz4(self._context)
        self.cccoefz3 = RootSeqCxRbanaInhiresCh4Cccoefz3(self._context)
        self.cccoefs2 = RootSeqCxRbanaInhiresCh4Cccoefs2(self._context)
        self.cccoefz2 = RootSeqCxRbanaInhiresCh4Cccoefz2(self._context)
        self.cccoefx0 = RootSeqCxRbanaInhiresCh4Cccoefx0(self._context)
        self.cccoefz0 = RootSeqCxRbanaInhiresCh4Cccoefz0(self._context)
        self.cccoefy4 = RootSeqCxRbanaInhiresCh4Cccoefy4(self._context)


class RootSeqCxRbanaInhires(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhires'
        self.ch4 = RootSeqCxRbanaInhiresCh4(self._context)
        self.ch2 = RootSeqCxRbanaInhiresCh2(self._context)
        self.ch6 = RootSeqCxRbanaInhiresCh6(self._context)
        self.ch8 = RootSeqCxRbanaInhiresCh8(self._context)
        self.ch5 = RootSeqCxRbanaInhiresCh5(self._context)
        self.ch1 = RootSeqCxRbanaInhiresCh1(self._context)
        self.ch7 = RootSeqCxRbanaInhiresCh7(self._context)
        self.ch3 = RootSeqCxRbanaInhiresCh3(self._context)
        self.ch12 = RootSeqCxRbanaInhiresCh12(self._context)
        self.ch11 = RootSeqCxRbanaInhiresCh11(self._context)
        self.ch9 = RootSeqCxRbanaInhiresCh9(self._context)
        self.ch10 = RootSeqCxRbanaInhiresCh10(self._context)


class RootSeqCxRbanaOrtSgleStatusAveraging(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.status.averaging'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.status.averaging.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.status.averaging.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.status.averaging.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.status.averaging.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.status.averaging.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.status.averaging.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.status'
        self.averaging = RootSeqCxRbanaOrtSgleStatusAveraging(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleMinposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.minposition'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.minposition.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.minposition.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleAmplitudesample(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.amplitudesample'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.amplitudesample.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.amplitudesample.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleFreewavebeginsample(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.freewavebeginsample'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.freewavebeginsample.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.freewavebeginsample.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleBaselineamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.baselineamplitude'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.baselineamplitude.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.baselineamplitude.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.minvalue.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleBaselinewindowendsample(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.baselinewindowendsample'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.baselinewindowendsample.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.baselinewindowendsample.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleControlAveragestart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.control.averagestart'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.averagestart.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.averagestart.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.averagestart.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.averagestart.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.averagestart.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.averagestart.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleControlAveragestop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.control.averagestop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.averagestop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.averagestop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.averagestop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.averagestop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.averagestop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.averagestop.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleControlFreewaveoutputenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.control.freewaveoutputenable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.freewaveoutputenable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.freewaveoutputenable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.freewaveoutputenable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.freewaveoutputenable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.freewaveoutputenable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.freewaveoutputenable.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleControlEnablebaselinecontroller(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.control.enablebaselinecontroller'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.enablebaselinecontroller.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.enablebaselinecontroller.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.enablebaselinecontroller.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.enablebaselinecontroller.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.enablebaselinecontroller.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.enablebaselinecontroller.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleControlInputselect(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.control.inputselect'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.inputselect.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.inputselect.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.inputselect.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.inputselect.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.inputselect.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.inputselect.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleControlUpdatesamplevalues(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.control.updatesamplevalues'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.updatesamplevalues.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.updatesamplevalues.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.updatesamplevalues.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.updatesamplevalues.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.updatesamplevalues.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.updatesamplevalues.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.control'
        self.updatesamplevalues = RootSeqCxRbanaOrtSgleControlUpdatesamplevalues(self._context)
        self.inputselect = RootSeqCxRbanaOrtSgleControlInputselect(self._context)
        self.enablebaselinecontroller = RootSeqCxRbanaOrtSgleControlEnablebaselinecontroller(self._context)
        self.freewaveoutputenable = RootSeqCxRbanaOrtSgleControlFreewaveoutputenable(self._context)
        self.averagestop = RootSeqCxRbanaOrtSgleControlAveragestop(self._context)
        self.averagestart = RootSeqCxRbanaOrtSgleControlAveragestart(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleSamplesperperiodSamplesperperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.samplesperperiod.samplesperperiod'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.samplesperperiod.samplesperperiod.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.samplesperperiod.samplesperperiod.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.samplesperperiod.samplesperperiod.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.samplesperperiod.samplesperperiod.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.samplesperperiod.samplesperperiod.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.samplesperperiod.samplesperperiod.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleSamplesperperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.samplesperperiod'
        self.samplesperperiod = RootSeqCxRbanaOrtSgleSamplesperperiodSamplesperperiod(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.samplesperperiod.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.samplesperperiod.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleCantileversamplesperperiodSamplesperperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.samplesperperiod'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.samplesperperiod.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.samplesperperiod.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.samplesperperiod.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.samplesperperiod.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.samplesperperiod.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.samplesperperiod.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleCantileversamplesperperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod'
        self.samplesperperiod = RootSeqCxRbanaOrtSgleCantileversamplesperperiodSamplesperperiod(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.cantileversamplesperperiod.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleAverageperiodsAverageperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.averageperiods.averageperiod'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.averageperiods.averageperiod.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.averageperiods.averageperiod.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.averageperiods.averageperiod.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.averageperiods.averageperiod.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.averageperiods.averageperiod.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.averageperiods.averageperiod.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleAverageperiods(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.averageperiods'
        self.averageperiod = RootSeqCxRbanaOrtSgleAverageperiodsAverageperiod(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.averageperiods.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.averageperiods.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleAmplitudereduction(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.amplitudereduction'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.amplitudereduction.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.amplitudereduction.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleExcitationamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.excitationamplitude'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.excitationamplitude.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.excitationamplitude.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleBaselinemultiplier(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.baselinemultiplier'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.baselinemultiplier.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.baselinemultiplier.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgleBaselinewindowbeginsample(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle.baselinewindowbeginsample'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.ort.sgle.baselinewindowbeginsample.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.ort.sgle.baselinewindowbeginsample.regaddr', int(new_val))


class RootSeqCxRbanaOrtSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort.sgle'
        self.baselinewindowbeginsample = RootSeqCxRbanaOrtSgleBaselinewindowbeginsample(self._context)
        self.baselinemultiplier = RootSeqCxRbanaOrtSgleBaselinemultiplier(self._context)
        self.excitationamplitude = RootSeqCxRbanaOrtSgleExcitationamplitude(self._context)
        self.amplitudereduction = RootSeqCxRbanaOrtSgleAmplitudereduction(self._context)
        self.averageperiods = RootSeqCxRbanaOrtSgleAverageperiods(self._context)
        self.cantileversamplesperperiod = RootSeqCxRbanaOrtSgleCantileversamplesperperiod(self._context)
        self.samplesperperiod = RootSeqCxRbanaOrtSgleSamplesperperiod(self._context)
        self.control = RootSeqCxRbanaOrtSgleControl(self._context)
        self.baselinewindowendsample = RootSeqCxRbanaOrtSgleBaselinewindowendsample(self._context)
        self.minvalue = RootSeqCxRbanaOrtSgleMinvalue(self._context)
        self.baselineamplitude = RootSeqCxRbanaOrtSgleBaselineamplitude(self._context)
        self.freewavebeginsample = RootSeqCxRbanaOrtSgleFreewavebeginsample(self._context)
        self.amplitudesample = RootSeqCxRbanaOrtSgleAmplitudesample(self._context)
        self.minposition = RootSeqCxRbanaOrtSgleMinposition(self._context)
        self.status = RootSeqCxRbanaOrtSgleStatus(self._context)


class RootSeqCxRbanaOrt(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.ort'
        self.sgle = RootSeqCxRbanaOrtSgle(self._context)


class RootSeqCxRbanaOutfastcommonSgleDampinggain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.dampinggain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.dampinggain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.dampinggain.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddamping1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddamping1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping1.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddamping3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddamping3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping3.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddamping2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddamping2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping2.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation2.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlSelectout1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.selectout1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout1.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlSelectout2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.selectout2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout2.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation4'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation4.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation4.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation4.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation4.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation4.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation3.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalmodulation1.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlSelectout3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.selectout3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout3.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddamping4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddamping4'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping4.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping4.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping4.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping4.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddamping4.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation4'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation4.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation4.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation4.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation4.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation4.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlSelectout4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.selectout4'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout4.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout4.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout4.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout4.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.selectout4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.selectout4.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation3.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle.control'
        self.adddigitalhiresmodulation3 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation3(self._context)
        self.selectout4 = RootSeqCxRbanaOutfastcommonSgleControlSelectout4(self._context)
        self.adddigitalhiresmodulation4 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation4(self._context)
        self.adddamping4 = RootSeqCxRbanaOutfastcommonSgleControlAdddamping4(self._context)
        self.selectout3 = RootSeqCxRbanaOutfastcommonSgleControlSelectout3(self._context)
        self.adddigitalmodulation1 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation1(self._context)
        self.adddigitalmodulation3 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation3(self._context)
        self.adddigitalmodulation4 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation4(self._context)
        self.selectout2 = RootSeqCxRbanaOutfastcommonSgleControlSelectout2(self._context)
        self.selectout1 = RootSeqCxRbanaOutfastcommonSgleControlSelectout1(self._context)
        self.adddigitalmodulation2 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalmodulation2(self._context)
        self.adddamping2 = RootSeqCxRbanaOutfastcommonSgleControlAdddamping2(self._context)
        self.adddigitalhiresmodulation2 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation2(self._context)
        self.adddamping3 = RootSeqCxRbanaOutfastcommonSgleControlAdddamping3(self._context)
        self.adddigitalhiresmodulation1 = RootSeqCxRbanaOutfastcommonSgleControlAdddigitalhiresmodulation1(self._context)
        self.adddamping1 = RootSeqCxRbanaOutfastcommonSgleControlAdddamping1(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfastcommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfastcommon.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaOutfastcommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon.sgle'
        self.control = RootSeqCxRbanaOutfastcommonSgleControl(self._context)
        self.dampinggain = RootSeqCxRbanaOutfastcommonSgleDampinggain(self._context)


class RootSeqCxRbanaOutfastcommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfastcommon'
        self.sgle = RootSeqCxRbanaOutfastcommonSgle(self._context)


class RootSeqCxRbanaInhirescommonSgleControlCh3bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch3bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch3bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch3bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch3bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch3bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch3bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch3bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh10bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch10bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch10bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch10bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch10bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch10bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch10bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch10bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh1bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch1bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch1bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch1bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch1bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch1bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch1bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch1bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh12bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch12bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch12bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch12bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch12bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch12bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch12bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch12bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh5bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch5bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch5bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch5bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch5bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch5bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch5bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch5bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh11bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch11bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch11bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch11bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch11bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch11bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch11bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch11bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh7bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch7bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch7bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch7bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch7bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch7bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch7bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch7bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh4bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch4bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch4bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch4bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch4bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch4bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch4bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch4bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh2bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch2bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch2bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch2bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch2bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch2bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch2bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch2bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh6bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch6bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch6bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch6bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch6bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch6bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch6bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch6bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh9bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch9bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch9bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch9bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch9bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch9bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch9bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch9bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControlCh8bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control.ch8bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch8bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch8bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch8bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch8bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.ch8bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.ch8bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.control'
        self.ch8bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh8bypassfilter(self._context)
        self.ch9bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh9bypassfilter(self._context)
        self.ch6bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh6bypassfilter(self._context)
        self.ch2bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh2bypassfilter(self._context)
        self.ch4bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh4bypassfilter(self._context)
        self.ch7bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh7bypassfilter(self._context)
        self.ch11bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh11bypassfilter(self._context)
        self.ch5bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh5bypassfilter(self._context)
        self.ch12bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh12bypassfilter(self._context)
        self.ch1bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh1bypassfilter(self._context)
        self.ch10bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh10bypassfilter(self._context)
        self.ch3bypassfilter = RootSeqCxRbanaInhirescommonSgleControlCh3bypassfilter(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleAafcoefAddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.aafcoef.addr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.addr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.addr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.addr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.addr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.addr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.addr.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleAafcoefData(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.aafcoef.data'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.data.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.data.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.data.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.data.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.data.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.data.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgleAafcoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle.aafcoef'
        self.data = RootSeqCxRbanaInhirescommonSgleAafcoefData(self._context)
        self.addr = RootSeqCxRbanaInhirescommonSgleAafcoefAddr(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.inhirescommon.sgle.aafcoef.regaddr', int(new_val))


class RootSeqCxRbanaInhirescommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon.sgle'
        self.aafcoef = RootSeqCxRbanaInhirescommonSgleAafcoef(self._context)
        self.control = RootSeqCxRbanaInhirescommonSgleControl(self._context)


class RootSeqCxRbanaInhirescommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.inhirescommon'
        self.sgle = RootSeqCxRbanaInhirescommonSgle(self._context)


class RootSeqCxRbanaInfastCh3Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.gain.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.offset.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch3.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch3.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch3'
        self.cccoefx1 = RootSeqCxRbanaInfastCh3Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInfastCh3Cccoefy1(self._context)
        self.cccoefy2 = RootSeqCxRbanaInfastCh3Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInfastCh3Cccoefy0(self._context)
        self.cccoefx0 = RootSeqCxRbanaInfastCh3Cccoefx0(self._context)
        self.cccoefz1 = RootSeqCxRbanaInfastCh3Cccoefz1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInfastCh3Cccoefx2(self._context)
        self.currentinval = RootSeqCxRbanaInfastCh3Currentinval(self._context)
        self.cccoefz2 = RootSeqCxRbanaInfastCh3Cccoefz2(self._context)
        self.offset = RootSeqCxRbanaInfastCh3Offset(self._context)
        self.cccoefz0 = RootSeqCxRbanaInfastCh3Cccoefz0(self._context)
        self.gain = RootSeqCxRbanaInfastCh3Gain(self._context)


class RootSeqCxRbanaInfastCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.gain.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.offset.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch2.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch2.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch2'
        self.cccoefx1 = RootSeqCxRbanaInfastCh2Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInfastCh2Cccoefy1(self._context)
        self.cccoefy2 = RootSeqCxRbanaInfastCh2Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInfastCh2Cccoefy0(self._context)
        self.cccoefx0 = RootSeqCxRbanaInfastCh2Cccoefx0(self._context)
        self.cccoefz1 = RootSeqCxRbanaInfastCh2Cccoefz1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInfastCh2Cccoefx2(self._context)
        self.currentinval = RootSeqCxRbanaInfastCh2Currentinval(self._context)
        self.cccoefz2 = RootSeqCxRbanaInfastCh2Cccoefz2(self._context)
        self.offset = RootSeqCxRbanaInfastCh2Offset(self._context)
        self.cccoefz0 = RootSeqCxRbanaInfastCh2Cccoefz0(self._context)
        self.gain = RootSeqCxRbanaInfastCh2Gain(self._context)


class RootSeqCxRbanaInfastCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.gain.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefz0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.offset.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefz2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefz2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefz2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefz2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.currentinval.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefx2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefx2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefx2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefx2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefz1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefz1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefz1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefz1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefx0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefy0.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefy2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefy2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefy2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefy2.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefy1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefy1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefy1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefy1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1Cccoefx1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1.cccoefx1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.infast.ch1.cccoefx1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.infast.ch1.cccoefx1.regaddr', int(new_val))


class RootSeqCxRbanaInfastCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast.ch1'
        self.cccoefx1 = RootSeqCxRbanaInfastCh1Cccoefx1(self._context)
        self.cccoefy1 = RootSeqCxRbanaInfastCh1Cccoefy1(self._context)
        self.cccoefy2 = RootSeqCxRbanaInfastCh1Cccoefy2(self._context)
        self.cccoefy0 = RootSeqCxRbanaInfastCh1Cccoefy0(self._context)
        self.cccoefx0 = RootSeqCxRbanaInfastCh1Cccoefx0(self._context)
        self.cccoefz1 = RootSeqCxRbanaInfastCh1Cccoefz1(self._context)
        self.cccoefx2 = RootSeqCxRbanaInfastCh1Cccoefx2(self._context)
        self.currentinval = RootSeqCxRbanaInfastCh1Currentinval(self._context)
        self.cccoefz2 = RootSeqCxRbanaInfastCh1Cccoefz2(self._context)
        self.offset = RootSeqCxRbanaInfastCh1Offset(self._context)
        self.cccoefz0 = RootSeqCxRbanaInfastCh1Cccoefz0(self._context)
        self.gain = RootSeqCxRbanaInfastCh1Gain(self._context)


class RootSeqCxRbanaInfast(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.infast'
        self.ch1 = RootSeqCxRbanaInfastCh1(self._context)
        self.ch2 = RootSeqCxRbanaInfastCh2(self._context)
        self.ch3 = RootSeqCxRbanaInfastCh3(self._context)


class RootSeqCxRbanaOuthiresCh10Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh10ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh10ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh10ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh10ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch10.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch10.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh10(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch10'
        self.gain = RootSeqCxRbanaOuthiresCh10Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh10Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh10Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh10Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh10Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh10Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh10Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh10Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh10Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh9Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh9ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh9ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh9ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh9ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch9.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch9.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh9(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch9'
        self.gain = RootSeqCxRbanaOuthiresCh9Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh9Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh9Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh9Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh9Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh9Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh9Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh9Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh9Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh11Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh11ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh11ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh11ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh11ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch11.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch11.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh11(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch11'
        self.gain = RootSeqCxRbanaOuthiresCh11Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh11Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh11Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh11Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh11Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh11Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh11Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh11Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh11Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh12Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh12ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh12ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh12ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh12ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch12.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch12.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh12(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch12'
        self.gain = RootSeqCxRbanaOuthiresCh12Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh12Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh12Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh12Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh12Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh12Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh12Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh12Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh12Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh3Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh3ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh3ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh3ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh3ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch3.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch3.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch3'
        self.gain = RootSeqCxRbanaOuthiresCh3Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh3Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh3Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh3Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh3Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh3Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh3Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh3Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh3Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh7Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh7ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh7ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh7ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh7ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch7.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch7.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch7'
        self.gain = RootSeqCxRbanaOuthiresCh7Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh7Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh7Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh7Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh7Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh7Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh7Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh7Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh7Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh1Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh1ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh1ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh1ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh1ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch1.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch1'
        self.gain = RootSeqCxRbanaOuthiresCh1Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh1Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh1Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh1Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh1Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh1Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh1Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh1Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh1Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh5Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh5ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh5ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh5ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh5ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch5.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch5.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch5'
        self.gain = RootSeqCxRbanaOuthiresCh5Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh5Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh5Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh5Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh5Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh5Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh5Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh5Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh5Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh8Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh8ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh8ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh8ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh8ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch8.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch8.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh8(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch8'
        self.gain = RootSeqCxRbanaOuthiresCh8Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh8Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh8Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh8Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh8Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh8Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh8Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh8Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh8Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh6Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh6ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh6ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh6ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh6ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch6.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch6.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch6'
        self.gain = RootSeqCxRbanaOuthiresCh6Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh6Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh6Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh6Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh6Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh6Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh6Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh6Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh6Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh2Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh2ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh2ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh2ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh2ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch2.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch2'
        self.gain = RootSeqCxRbanaOuthiresCh2Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh2Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh2Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh2Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh2Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh2Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh2Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh2Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh2Glitchcorr(self._context)


class RootSeqCxRbanaOuthiresCh4Glitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.glitchcorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.filterval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Lowordgaincorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.lowordgaincorr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.lowordgaincorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.lowordgaincorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.offset.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Slewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.slewrate'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.slewrate.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.slewrate.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.selectout.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.bypassfilter.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4ControlGlitchcorr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.control.glitchcorr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.glitchcorr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.glitchcorr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.glitchcorr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.glitchcorr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.glitchcorr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.glitchcorr.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.control'
        self.glitchcorr = RootSeqCxRbanaOuthiresCh4ControlGlitchcorr(self._context)
        self.bypassfilter = RootSeqCxRbanaOuthiresCh4ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqCxRbanaOuthiresCh4ControlAdddigitalmodulation(self._context)
        self.selectout = RootSeqCxRbanaOuthiresCh4ControlSelectout(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhires.ch4.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhires.ch4.gain.regaddr', int(new_val))


class RootSeqCxRbanaOuthiresCh4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires.ch4'
        self.gain = RootSeqCxRbanaOuthiresCh4Gain(self._context)
        self.testvalue = RootSeqCxRbanaOuthiresCh4Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOuthiresCh4Currentoutval(self._context)
        self.control = RootSeqCxRbanaOuthiresCh4Control(self._context)
        self.slewrate = RootSeqCxRbanaOuthiresCh4Slewrate(self._context)
        self.offset = RootSeqCxRbanaOuthiresCh4Offset(self._context)
        self.lowordgaincorr = RootSeqCxRbanaOuthiresCh4Lowordgaincorr(self._context)
        self.filterval = RootSeqCxRbanaOuthiresCh4Filterval(self._context)
        self.glitchcorr = RootSeqCxRbanaOuthiresCh4Glitchcorr(self._context)


class RootSeqCxRbanaOuthires(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhires'
        self.ch4 = RootSeqCxRbanaOuthiresCh4(self._context)
        self.ch2 = RootSeqCxRbanaOuthiresCh2(self._context)
        self.ch6 = RootSeqCxRbanaOuthiresCh6(self._context)
        self.ch8 = RootSeqCxRbanaOuthiresCh8(self._context)
        self.ch5 = RootSeqCxRbanaOuthiresCh5(self._context)
        self.ch1 = RootSeqCxRbanaOuthiresCh1(self._context)
        self.ch7 = RootSeqCxRbanaOuthiresCh7(self._context)
        self.ch3 = RootSeqCxRbanaOuthiresCh3(self._context)
        self.ch12 = RootSeqCxRbanaOuthiresCh12(self._context)
        self.ch11 = RootSeqCxRbanaOuthiresCh11(self._context)
        self.ch9 = RootSeqCxRbanaOuthiresCh9(self._context)
        self.ch10 = RootSeqCxRbanaOuthiresCh10(self._context)


class RootSeqCxRbanaInternaSgleControlRst8chconverters(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.interna.sgle.control.rst8chconverters'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.interna.sgle.control.rst8chconverters.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.interna.sgle.control.rst8chconverters.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.interna.sgle.control.rst8chconverters.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.interna.sgle.control.rst8chconverters.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.interna.sgle.control.rst8chconverters.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.interna.sgle.control.rst8chconverters.regaddr', int(new_val))


class RootSeqCxRbanaInternaSgleControlStatusled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.interna.sgle.control.statusled'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.interna.sgle.control.statusled.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.interna.sgle.control.statusled.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.interna.sgle.control.statusled.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.interna.sgle.control.statusled.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.interna.sgle.control.statusled.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.interna.sgle.control.statusled.regaddr', int(new_val))


class RootSeqCxRbanaInternaSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.interna.sgle.control'
        self.statusled = RootSeqCxRbanaInternaSgleControlStatusled(self._context)
        self.rst8chconverters = RootSeqCxRbanaInternaSgleControlRst8chconverters(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.interna.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.interna.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaInternaSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.interna.sgle'
        self.control = RootSeqCxRbanaInternaSgleControl(self._context)


class RootSeqCxRbanaInterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.interna'
        self.sgle = RootSeqCxRbanaInternaSgle(self._context)


class RootSeqCxRbanaOutfastCh3Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch3.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch3.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch3.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh3Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch3.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch3.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch3.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh3Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch3.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch3.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch3.offset.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh3Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch3.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch3.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch3.gain.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch3'
        self.gain = RootSeqCxRbanaOutfastCh3Gain(self._context)
        self.offset = RootSeqCxRbanaOutfastCh3Offset(self._context)
        self.testvalue = RootSeqCxRbanaOutfastCh3Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOutfastCh3Currentoutval(self._context)


class RootSeqCxRbanaOutfastCh2Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch2.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch2.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch2.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh2Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch2.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch2.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch2.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch2.offset.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch2.gain.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch2'
        self.gain = RootSeqCxRbanaOutfastCh2Gain(self._context)
        self.offset = RootSeqCxRbanaOutfastCh2Offset(self._context)
        self.testvalue = RootSeqCxRbanaOutfastCh2Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOutfastCh2Currentoutval(self._context)


class RootSeqCxRbanaOutfastCh1Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch1.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch1.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch1.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh1Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch1.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch1.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch1.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch1.offset.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch1.gain.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch1'
        self.gain = RootSeqCxRbanaOutfastCh1Gain(self._context)
        self.offset = RootSeqCxRbanaOutfastCh1Offset(self._context)
        self.testvalue = RootSeqCxRbanaOutfastCh1Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOutfastCh1Currentoutval(self._context)


class RootSeqCxRbanaOutfastCh4Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch4.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch4.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch4.currentoutval.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh4Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch4.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch4.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch4.testvalue.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh4Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch4.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch4.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch4.offset.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh4Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch4.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outfast.ch4.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outfast.ch4.gain.regaddr', int(new_val))


class RootSeqCxRbanaOutfastCh4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast.ch4'
        self.gain = RootSeqCxRbanaOutfastCh4Gain(self._context)
        self.offset = RootSeqCxRbanaOutfastCh4Offset(self._context)
        self.testvalue = RootSeqCxRbanaOutfastCh4Testvalue(self._context)
        self.currentoutval = RootSeqCxRbanaOutfastCh4Currentoutval(self._context)


class RootSeqCxRbanaOutfast(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outfast'
        self.ch4 = RootSeqCxRbanaOutfastCh4(self._context)
        self.ch1 = RootSeqCxRbanaOutfastCh1(self._context)
        self.ch2 = RootSeqCxRbanaOutfastCh2(self._context)
        self.ch3 = RootSeqCxRbanaOutfastCh3(self._context)


class RootSeqCxRbanaUserioSgleDigitalin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.digitalin'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.digitalin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.digitalin.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut1src(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out1src'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1src.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1src.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1src.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1src.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1src.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1src.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut2level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out2level'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2level.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2level.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2level.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2level.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2level.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut1level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out1level'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1level.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1level.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1level.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1level.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1level.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut2type(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out2type'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2type.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2type.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2type.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2type.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2type.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2type.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlIn2enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.in2enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.in2enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.in2enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.in2enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.in2enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.in2enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.in2enable.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut2src(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out2src'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2src.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2src.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2src.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2src.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2src.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2src.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut1type(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out1type'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1type.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1type.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1type.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1type.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1type.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1type.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut2enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out2enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out2enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out2enable.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlOut1enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.out1enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.out1enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.out1enable.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControlIn1enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control.in1enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.in1enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.in1enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.in1enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.in1enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.in1enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.in1enable.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle.control'
        self.in1enable = RootSeqCxRbanaUserioSgleControlIn1enable(self._context)
        self.out1enable = RootSeqCxRbanaUserioSgleControlOut1enable(self._context)
        self.out2enable = RootSeqCxRbanaUserioSgleControlOut2enable(self._context)
        self.out1type = RootSeqCxRbanaUserioSgleControlOut1type(self._context)
        self.out2src = RootSeqCxRbanaUserioSgleControlOut2src(self._context)
        self.in2enable = RootSeqCxRbanaUserioSgleControlIn2enable(self._context)
        self.out2type = RootSeqCxRbanaUserioSgleControlOut2type(self._context)
        self.out1level = RootSeqCxRbanaUserioSgleControlOut1level(self._context)
        self.out2level = RootSeqCxRbanaUserioSgleControlOut2level(self._context)
        self.out1src = RootSeqCxRbanaUserioSgleControlOut1src(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.userio.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.userio.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaUserioSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio.sgle'
        self.control = RootSeqCxRbanaUserioSgleControl(self._context)
        self.digitalin = RootSeqCxRbanaUserioSgleDigitalin(self._context)


class RootSeqCxRbanaUserio(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.userio'
        self.sgle = RootSeqCxRbanaUserioSgle(self._context)


class RootSeqCxRbanaRampgenTipvoltageStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.status'
        self.countup = RootSeqCxRbanaRampgenTipvoltageStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenTipvoltageStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenTipvoltageStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenTipvoltageStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenTipvoltageStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltageControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage.control'
        self.start = RootSeqCxRbanaRampgenTipvoltageControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenTipvoltageControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenTipvoltageControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenTipvoltageControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenTipvoltageControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.tipvoltage.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.tipvoltage.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTipvoltage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.tipvoltage'
        self.control = RootSeqCxRbanaRampgenTipvoltageControl(self._context)
        self.out = RootSeqCxRbanaRampgenTipvoltageOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenTipvoltageLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenTipvoltageLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenTipvoltageValue(self._context)
        self.increment = RootSeqCxRbanaRampgenTipvoltageIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenTipvoltageStatus(self._context)


class RootSeqCxRbanaRampgenUser4StatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4StatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4StatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4StatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4StatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.status'
        self.countup = RootSeqCxRbanaRampgenUser4StatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenUser4StatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenUser4StatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenUser4StatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenUser4StatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4Increment(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4Value(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4Limit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4Limit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4Out(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4ControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4ControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4ControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4ControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4.control'
        self.start = RootSeqCxRbanaRampgenUser4ControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenUser4ControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenUser4ControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenUser4ControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenUser4ControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.user4.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.user4.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.user4'
        self.control = RootSeqCxRbanaRampgenUser4Control(self._context)
        self.out = RootSeqCxRbanaRampgenUser4Out(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenUser4Limit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenUser4Limit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenUser4Value(self._context)
        self.increment = RootSeqCxRbanaRampgenUser4Increment(self._context)
        self.status = RootSeqCxRbanaRampgenUser4Status(self._context)


class RootSeqCxRbanaRampgenPlanezStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.status'
        self.countup = RootSeqCxRbanaRampgenPlanezStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenPlanezStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenPlanezStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenPlanezStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenPlanezStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanezControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez.control'
        self.start = RootSeqCxRbanaRampgenPlanezControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenPlanezControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenPlanezControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenPlanezControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenPlanezControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.planez.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.planez.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPlanez(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.planez'
        self.control = RootSeqCxRbanaRampgenPlanezControl(self._context)
        self.out = RootSeqCxRbanaRampgenPlanezOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenPlanezLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenPlanezLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenPlanezValue(self._context)
        self.increment = RootSeqCxRbanaRampgenPlanezIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenPlanezStatus(self._context)


class RootSeqCxRbanaRampgenPositionxStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.status'
        self.countup = RootSeqCxRbanaRampgenPositionxStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenPositionxStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenPositionxStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenPositionxStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenPositionxStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionxControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx.control'
        self.start = RootSeqCxRbanaRampgenPositionxControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenPositionxControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenPositionxControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenPositionxControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenPositionxControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positionx.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positionx.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positionx'
        self.control = RootSeqCxRbanaRampgenPositionxControl(self._context)
        self.out = RootSeqCxRbanaRampgenPositionxOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenPositionxLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenPositionxLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenPositionxValue(self._context)
        self.increment = RootSeqCxRbanaRampgenPositionxIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenPositionxStatus(self._context)


class RootSeqCxRbanaRampgenTestStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.status'
        self.countup = RootSeqCxRbanaRampgenTestStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenTestStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenTestStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenTestStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenTestStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTestControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test.control'
        self.start = RootSeqCxRbanaRampgenTestControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenTestControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenTestControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenTestControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenTestControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.test.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.test.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenTest(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.test'
        self.control = RootSeqCxRbanaRampgenTestControl(self._context)
        self.out = RootSeqCxRbanaRampgenTestOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenTestLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenTestLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenTestValue(self._context)
        self.increment = RootSeqCxRbanaRampgenTestIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenTestStatus(self._context)


class RootSeqCxRbanaRampgenApproachStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.status'
        self.countup = RootSeqCxRbanaRampgenApproachStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenApproachStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenApproachStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenApproachStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenApproachStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproachControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach.control'
        self.start = RootSeqCxRbanaRampgenApproachControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenApproachControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenApproachControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenApproachControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenApproachControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.approach.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.approach.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.approach'
        self.control = RootSeqCxRbanaRampgenApproachControl(self._context)
        self.out = RootSeqCxRbanaRampgenApproachOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenApproachLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenApproachLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenApproachValue(self._context)
        self.increment = RootSeqCxRbanaRampgenApproachIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenApproachStatus(self._context)


class RootSeqCxRbanaRampgenAlternatezStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.status'
        self.countup = RootSeqCxRbanaRampgenAlternatezStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenAlternatezStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenAlternatezStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenAlternatezStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenAlternatezStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatezControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez.control'
        self.start = RootSeqCxRbanaRampgenAlternatezControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenAlternatezControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenAlternatezControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenAlternatezControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenAlternatezControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.alternatez.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.alternatez.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenAlternatez(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.alternatez'
        self.control = RootSeqCxRbanaRampgenAlternatezControl(self._context)
        self.out = RootSeqCxRbanaRampgenAlternatezOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenAlternatezLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenAlternatezLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenAlternatezValue(self._context)
        self.increment = RootSeqCxRbanaRampgenAlternatezIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenAlternatezStatus(self._context)


class RootSeqCxRbanaRampgenPositionyStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.status'
        self.countup = RootSeqCxRbanaRampgenPositionyStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenPositionyStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenPositionyStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenPositionyStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenPositionyStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositionyControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony.control'
        self.start = RootSeqCxRbanaRampgenPositionyControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenPositionyControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenPositionyControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenPositionyControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenPositionyControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.positiony.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.positiony.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenPositiony(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.positiony'
        self.control = RootSeqCxRbanaRampgenPositionyControl(self._context)
        self.out = RootSeqCxRbanaRampgenPositionyOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenPositionyLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenPositionyLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenPositionyValue(self._context)
        self.increment = RootSeqCxRbanaRampgenPositionyIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenPositionyStatus(self._context)


class RootSeqCxRbanaRampgenMaxzStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.countup.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.status'
        self.countup = RootSeqCxRbanaRampgenMaxzStatusCountup(self._context)
        self.reachedupperlimit = RootSeqCxRbanaRampgenMaxzStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqCxRbanaRampgenMaxzStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqCxRbanaRampgenMaxzStatusReachedregularend(self._context)
        self.busy = RootSeqCxRbanaRampgenMaxzStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.status.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.increment.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.value.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.limit_neg.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.limit_pos.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.out.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.init.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.start.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxzControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz.control'
        self.start = RootSeqCxRbanaRampgenMaxzControlStart(self._context)
        self.abort = RootSeqCxRbanaRampgenMaxzControlAbort(self._context)
        self.init = RootSeqCxRbanaRampgenMaxzControlInit(self._context)
        self.stop = RootSeqCxRbanaRampgenMaxzControlStop(self._context)
        self.mode = RootSeqCxRbanaRampgenMaxzControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.rampgen.maxz.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.rampgen.maxz.control.regaddr', int(new_val))


class RootSeqCxRbanaRampgenMaxz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen.maxz'
        self.control = RootSeqCxRbanaRampgenMaxzControl(self._context)
        self.out = RootSeqCxRbanaRampgenMaxzOut(self._context)
        self.limit_pos = RootSeqCxRbanaRampgenMaxzLimit_pos(self._context)
        self.limit_neg = RootSeqCxRbanaRampgenMaxzLimit_neg(self._context)
        self.value = RootSeqCxRbanaRampgenMaxzValue(self._context)
        self.increment = RootSeqCxRbanaRampgenMaxzIncrement(self._context)
        self.status = RootSeqCxRbanaRampgenMaxzStatus(self._context)


class RootSeqCxRbanaRampgen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.rampgen'
        self.maxz = RootSeqCxRbanaRampgenMaxz(self._context)
        self.positiony = RootSeqCxRbanaRampgenPositiony(self._context)
        self.alternatez = RootSeqCxRbanaRampgenAlternatez(self._context)
        self.approach = RootSeqCxRbanaRampgenApproach(self._context)
        self.test = RootSeqCxRbanaRampgenTest(self._context)
        self.positionx = RootSeqCxRbanaRampgenPositionx(self._context)
        self.planez = RootSeqCxRbanaRampgenPlanez(self._context)
        self.user4 = RootSeqCxRbanaRampgenUser4(self._context)
        self.tipvoltage = RootSeqCxRbanaRampgenTipvoltage(self._context)


class RootSeqCxRbanaOuthirescommonSgleGpfiltrcoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon.sgle.gpfiltrcoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.gpfiltrcoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.gpfiltrcoef.regaddr', int(new_val))


class RootSeqCxRbanaOuthirescommonSgleGpfiltraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon.sgle.gpfiltraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.gpfiltraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.gpfiltraddr.regaddr', int(new_val))


class RootSeqCxRbanaOuthirescommonSgleControlGpflt_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon.sgle.control.gpflt_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.gpflt_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.gpflt_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.gpflt_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.gpflt_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.gpflt_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.gpflt_vld.regaddr', int(new_val))


class RootSeqCxRbanaOuthirescommonSgleControlOuthires_dac8delay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon.sgle.control.outhires_dac8delay'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.outhires_dac8delay.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.outhires_dac8delay.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.outhires_dac8delay.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.outhires_dac8delay.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.outhires_dac8delay.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.outhires_dac8delay.regaddr', int(new_val))


class RootSeqCxRbanaOuthirescommonSgleControlSelectmod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon.sgle.control.selectmod'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.selectmod.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.selectmod.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.selectmod.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.selectmod.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.selectmod.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.selectmod.regaddr', int(new_val))


class RootSeqCxRbanaOuthirescommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon.sgle.control'
        self.selectmod = RootSeqCxRbanaOuthirescommonSgleControlSelectmod(self._context)
        self.outhires_dac8delay = RootSeqCxRbanaOuthirescommonSgleControlOuthires_dac8delay(self._context)
        self.gpflt_vld = RootSeqCxRbanaOuthirescommonSgleControlGpflt_vld(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.outhirescommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.outhirescommon.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaOuthirescommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon.sgle'
        self.control = RootSeqCxRbanaOuthirescommonSgleControl(self._context)
        self.gpfiltraddr = RootSeqCxRbanaOuthirescommonSgleGpfiltraddr(self._context)
        self.gpfiltrcoef = RootSeqCxRbanaOuthirescommonSgleGpfiltrcoef(self._context)


class RootSeqCxRbanaOuthirescommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.outhirescommon'
        self.sgle = RootSeqCxRbanaOuthirescommonSgle(self._context)


class RootSeqCxRbanaAnalyzerTwoDeltafoffs_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.deltafoffs_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.deltafoffs_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.deltafoffs_hi.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoFltrcoeff(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.fltrcoeff'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.fltrcoeff.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.fltrcoeff.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiampkel'
        self.shift = RootSeqCxRbanaAnalyzerTwoKiampkelShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerTwoKiampkelShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerTwoKiampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoFlag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.flag'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.flag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.flag.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.ctrlbits.ampmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampmodulation.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpctrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCtrlbitsPhaseclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.ctrlbits.phaseclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.phaseclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.phaseclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.phaseclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.phaseclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.phaseclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.phaseclearaccu.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCtrlbitsPhasectrl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.ctrlbits.phasectrl'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.phasectrl.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.phasectrl.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.phasectrl.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.phasectrl.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.phasectrl.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.phasectrl.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.ctrlbits.ampclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampclearaccu.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpctrlpositiveaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCtrlbits(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.ctrlbits'
        self.ampctrlpositiveaccu = RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpctrlpositiveaccu(self._context)
        self.ampclearaccu = RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpclearaccu(self._context)
        self.phasectrl = RootSeqCxRbanaAnalyzerTwoCtrlbitsPhasectrl(self._context)
        self.phaseclearaccu = RootSeqCxRbanaAnalyzerTwoCtrlbitsPhaseclearaccu(self._context)
        self.ampctrlmode = RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpctrlmode(self._context)
        self.ampmodulation = RootSeqCxRbanaAnalyzerTwoCtrlbitsAmpmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.ctrlbits.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.ctrlbits.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoLockrangeshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.lockrangeshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.lockrangeshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.lockrangeshift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpphase'
        self.shift = RootSeqCxRbanaAnalyzerTwoKpphaseShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerTwoKpphaseShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerTwoKpphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpphase.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKpampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kpampkel'
        self.shift = RootSeqCxRbanaAnalyzerTwoKpampkelShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerTwoKpampkelShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerTwoKpampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kpampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kpampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoModampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.modampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.modampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.modampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoAmplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.amplitude'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.amplitude.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.amplitude.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoModeOpmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.mode.opmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.opmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.opmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.opmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.opmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.opmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.opmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoModePhasedetref(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.mode.phasedetref'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.phasedetref.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.phasedetref.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.phasedetref.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.phasedetref.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.phasedetref.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.phasedetref.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoModeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.mode.input'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.input.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.input.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.input.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.input.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.input.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.input.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoModeAnalyzerinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.mode.analyzerinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.analyzerinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.analyzerinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.analyzerinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.analyzerinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.analyzerinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.analyzerinput.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.mode'
        self.analyzerinput = RootSeqCxRbanaAnalyzerTwoModeAnalyzerinput(self._context)
        self.input = RootSeqCxRbanaAnalyzerTwoModeInput(self._context)
        self.phasedetref = RootSeqCxRbanaAnalyzerTwoModePhasedetref(self._context)
        self.opmode = RootSeqCxRbanaAnalyzerTwoModeOpmode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.mode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoPhaseshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.phaseshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.phaseshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.phaseshift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoSafetipSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.safetip.safetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.safetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.safetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.safetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.safetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.safetip.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoSafetipSafetipmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.safetip.safetipmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.safetipmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.safetipmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.safetipmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.safetipmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.safetipmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.safetipmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoSafetipSyncorsafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.safetip.syncorsafetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.syncorsafetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.syncorsafetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.syncorsafetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.syncorsafetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.syncorsafetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.syncorsafetip.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoSafetipThresholdmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.safetip.thresholdmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.thresholdmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.thresholdmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.thresholdmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.thresholdmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.thresholdmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.thresholdmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.safetip'
        self.thresholdmode = RootSeqCxRbanaAnalyzerTwoSafetipThresholdmode(self._context)
        self.syncorsafetip = RootSeqCxRbanaAnalyzerTwoSafetipSyncorsafetip(self._context)
        self.safetipmode = RootSeqCxRbanaAnalyzerTwoSafetipSafetipmode(self._context)
        self.safetip = RootSeqCxRbanaAnalyzerTwoSafetipSafetip(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.safetip.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoDelaycomp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.delaycomp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.delaycomp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.delaycomp.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoSetvalampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.setvalampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.setvalampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.setvalampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoThreshold(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.threshold'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.threshold.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.threshold.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCenterfreq_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.centerfreq_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.centerfreq_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.centerfreq_hi.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoKiphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.kiphase'
        self.shift = RootSeqCxRbanaAnalyzerTwoKiphaseShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerTwoKiphaseShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerTwoKiphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.kiphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.kiphase.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoDeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.deltaf'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.deltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.deltaf.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoX(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.x'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.x.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.x.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoY(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.y'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.y.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.y.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoPhase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.phase'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.phase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.phase.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoSetptampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.setptampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.setptampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.setptampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoDeltafoffs_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.deltafoffs_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.deltafoffs_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.deltafoffs_lo.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoCenterfreq_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.centerfreq_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.centerfreq_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.centerfreq_lo.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoControl1Fltr_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.control1.fltr_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.fltr_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.fltr_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.fltr_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.fltr_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.fltr_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.fltr_vld.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoControl1Distdeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.control1.distdeltaf'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.distdeltaf.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.distdeltaf.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.distdeltaf.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.distdeltaf.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.distdeltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.distdeltaf.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoControl1Filtaddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.control1.filtaddr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.filtaddr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.filtaddr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.filtaddr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.filtaddr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.filtaddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.filtaddr.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoControl1Outputsourceid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.control1.outputsourceid'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.outputsourceid.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.outputsourceid.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.outputsourceid.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.outputsourceid.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.outputsourceid.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.outputsourceid.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoControl1Clearflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.control1.clearflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.clearflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.clearflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.clearflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.clearflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.clearflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.clearflag.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoControl1Enabledcblock(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.control1.enabledcblock'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.enabledcblock.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.enabledcblock.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.enabledcblock.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.enabledcblock.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.enabledcblock.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.enabledcblock.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoControl1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.control1'
        self.enabledcblock = RootSeqCxRbanaAnalyzerTwoControl1Enabledcblock(self._context)
        self.clearflag = RootSeqCxRbanaAnalyzerTwoControl1Clearflag(self._context)
        self.outputsourceid = RootSeqCxRbanaAnalyzerTwoControl1Outputsourceid(self._context)
        self.filtaddr = RootSeqCxRbanaAnalyzerTwoControl1Filtaddr(self._context)
        self.distdeltaf = RootSeqCxRbanaAnalyzerTwoControl1Distdeltaf(self._context)
        self.fltr_vld = RootSeqCxRbanaAnalyzerTwoControl1Fltr_vld(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.control1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.control1.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwoDisscp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two.disscp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.two.disscp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.two.disscp.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerTwo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.two'
        self.disscp = RootSeqCxRbanaAnalyzerTwoDisscp(self._context)
        self.control1 = RootSeqCxRbanaAnalyzerTwoControl1(self._context)
        self.centerfreq_lo = RootSeqCxRbanaAnalyzerTwoCenterfreq_lo(self._context)
        self.deltafoffs_lo = RootSeqCxRbanaAnalyzerTwoDeltafoffs_lo(self._context)
        self.setptampkel = RootSeqCxRbanaAnalyzerTwoSetptampkel(self._context)
        self.phase = RootSeqCxRbanaAnalyzerTwoPhase(self._context)
        self.y = RootSeqCxRbanaAnalyzerTwoY(self._context)
        self.x = RootSeqCxRbanaAnalyzerTwoX(self._context)
        self.deltaf = RootSeqCxRbanaAnalyzerTwoDeltaf(self._context)
        self.kiphase = RootSeqCxRbanaAnalyzerTwoKiphase(self._context)
        self.centerfreq_hi = RootSeqCxRbanaAnalyzerTwoCenterfreq_hi(self._context)
        self.threshold = RootSeqCxRbanaAnalyzerTwoThreshold(self._context)
        self.setvalampkel = RootSeqCxRbanaAnalyzerTwoSetvalampkel(self._context)
        self.delaycomp = RootSeqCxRbanaAnalyzerTwoDelaycomp(self._context)
        self.safetip = RootSeqCxRbanaAnalyzerTwoSafetip(self._context)
        self.phaseshift = RootSeqCxRbanaAnalyzerTwoPhaseshift(self._context)
        self.mode = RootSeqCxRbanaAnalyzerTwoMode(self._context)
        self.amplitude = RootSeqCxRbanaAnalyzerTwoAmplitude(self._context)
        self.modampkel = RootSeqCxRbanaAnalyzerTwoModampkel(self._context)
        self.kpampkel = RootSeqCxRbanaAnalyzerTwoKpampkel(self._context)
        self.kpphase = RootSeqCxRbanaAnalyzerTwoKpphase(self._context)
        self.lockrangeshift = RootSeqCxRbanaAnalyzerTwoLockrangeshift(self._context)
        self.ctrlbits = RootSeqCxRbanaAnalyzerTwoCtrlbits(self._context)
        self.flag = RootSeqCxRbanaAnalyzerTwoFlag(self._context)
        self.kiampkel = RootSeqCxRbanaAnalyzerTwoKiampkel(self._context)
        self.fltrcoeff = RootSeqCxRbanaAnalyzerTwoFltrcoeff(self._context)
        self.deltafoffs_hi = RootSeqCxRbanaAnalyzerTwoDeltafoffs_hi(self._context)


class RootSeqCxRbanaAnalyzerOneDeltafoffs_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.deltafoffs_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.deltafoffs_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.deltafoffs_hi.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneFltrcoeff(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.fltrcoeff'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.fltrcoeff.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.fltrcoeff.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiampkel'
        self.shift = RootSeqCxRbanaAnalyzerOneKiampkelShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerOneKiampkelShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerOneKiampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneFlag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.flag'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.flag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.flag.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCtrlbitsAmpmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.ctrlbits.ampmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampmodulation.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCtrlbitsAmpctrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCtrlbitsPhaseclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.ctrlbits.phaseclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.phaseclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.phaseclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.phaseclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.phaseclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.phaseclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.phaseclearaccu.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCtrlbitsPhasectrl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.ctrlbits.phasectrl'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.phasectrl.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.phasectrl.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.phasectrl.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.phasectrl.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.phasectrl.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.phasectrl.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCtrlbitsAmpclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.ctrlbits.ampclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampclearaccu.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCtrlbitsAmpctrlpositiveaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCtrlbits(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.ctrlbits'
        self.ampctrlpositiveaccu = RootSeqCxRbanaAnalyzerOneCtrlbitsAmpctrlpositiveaccu(self._context)
        self.ampclearaccu = RootSeqCxRbanaAnalyzerOneCtrlbitsAmpclearaccu(self._context)
        self.phasectrl = RootSeqCxRbanaAnalyzerOneCtrlbitsPhasectrl(self._context)
        self.phaseclearaccu = RootSeqCxRbanaAnalyzerOneCtrlbitsPhaseclearaccu(self._context)
        self.ampctrlmode = RootSeqCxRbanaAnalyzerOneCtrlbitsAmpctrlmode(self._context)
        self.ampmodulation = RootSeqCxRbanaAnalyzerOneCtrlbitsAmpmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.ctrlbits.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.ctrlbits.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneLockrangeshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.lockrangeshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.lockrangeshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.lockrangeshift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpphase'
        self.shift = RootSeqCxRbanaAnalyzerOneKpphaseShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerOneKpphaseShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerOneKpphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpphase.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKpampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kpampkel'
        self.shift = RootSeqCxRbanaAnalyzerOneKpampkelShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerOneKpampkelShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerOneKpampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kpampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kpampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneModampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.modampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.modampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.modampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneAmplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.amplitude'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.amplitude.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.amplitude.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneModeOpmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.mode.opmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.opmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.opmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.opmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.opmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.opmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.opmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneModePhasedetref(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.mode.phasedetref'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.phasedetref.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.phasedetref.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.phasedetref.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.phasedetref.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.phasedetref.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.phasedetref.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneModeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.mode.input'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.input.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.input.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.input.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.input.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.input.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.input.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneModeAnalyzerinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.mode.analyzerinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.analyzerinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.analyzerinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.analyzerinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.analyzerinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.analyzerinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.analyzerinput.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.mode'
        self.analyzerinput = RootSeqCxRbanaAnalyzerOneModeAnalyzerinput(self._context)
        self.input = RootSeqCxRbanaAnalyzerOneModeInput(self._context)
        self.phasedetref = RootSeqCxRbanaAnalyzerOneModePhasedetref(self._context)
        self.opmode = RootSeqCxRbanaAnalyzerOneModeOpmode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.mode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOnePhaseshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.phaseshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.phaseshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.phaseshift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneSafetipSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.safetip.safetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.safetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.safetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.safetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.safetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.safetip.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneSafetipSafetipmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.safetip.safetipmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.safetipmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.safetipmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.safetipmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.safetipmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.safetipmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.safetipmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneSafetipSyncorsafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.safetip.syncorsafetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.syncorsafetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.syncorsafetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.syncorsafetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.syncorsafetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.syncorsafetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.syncorsafetip.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneSafetipThresholdmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.safetip.thresholdmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.thresholdmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.thresholdmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.thresholdmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.thresholdmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.thresholdmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.thresholdmode.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.safetip'
        self.thresholdmode = RootSeqCxRbanaAnalyzerOneSafetipThresholdmode(self._context)
        self.syncorsafetip = RootSeqCxRbanaAnalyzerOneSafetipSyncorsafetip(self._context)
        self.safetipmode = RootSeqCxRbanaAnalyzerOneSafetipSafetipmode(self._context)
        self.safetip = RootSeqCxRbanaAnalyzerOneSafetipSafetip(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.safetip.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneDelaycomp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.delaycomp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.delaycomp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.delaycomp.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneSetvalampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.setvalampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.setvalampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.setvalampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneThreshold(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.threshold'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.threshold.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.threshold.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCenterfreq_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.centerfreq_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.centerfreq_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.centerfreq_hi.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.factor.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.shiftdirection.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.shift.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneKiphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.kiphase'
        self.shift = RootSeqCxRbanaAnalyzerOneKiphaseShift(self._context)
        self.shiftdirection = RootSeqCxRbanaAnalyzerOneKiphaseShiftdirection(self._context)
        self.factor = RootSeqCxRbanaAnalyzerOneKiphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.kiphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.kiphase.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneDeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.deltaf'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.deltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.deltaf.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneX(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.x'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.x.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.x.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneY(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.y'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.y.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.y.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOnePhase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.phase'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.phase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.phase.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneSetptampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.setptampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.setptampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.setptampkel.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneDeltafoffs_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.deltafoffs_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.deltafoffs_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.deltafoffs_lo.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneCenterfreq_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.centerfreq_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.centerfreq_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.centerfreq_lo.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneControl1Fltr_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.control1.fltr_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.fltr_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.fltr_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.fltr_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.fltr_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.fltr_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.fltr_vld.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneControl1Distdeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.control1.distdeltaf'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.distdeltaf.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.distdeltaf.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.distdeltaf.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.distdeltaf.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.distdeltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.distdeltaf.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneControl1Filtaddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.control1.filtaddr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.filtaddr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.filtaddr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.filtaddr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.filtaddr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.filtaddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.filtaddr.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneControl1Outputsourceid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.control1.outputsourceid'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.outputsourceid.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.outputsourceid.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.outputsourceid.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.outputsourceid.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.outputsourceid.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.outputsourceid.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneControl1Clearflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.control1.clearflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.clearflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.clearflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.clearflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.clearflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.clearflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.clearflag.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneControl1Enabledcblock(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.control1.enabledcblock'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.enabledcblock.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.enabledcblock.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.enabledcblock.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.enabledcblock.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.enabledcblock.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.enabledcblock.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneControl1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.control1'
        self.enabledcblock = RootSeqCxRbanaAnalyzerOneControl1Enabledcblock(self._context)
        self.clearflag = RootSeqCxRbanaAnalyzerOneControl1Clearflag(self._context)
        self.outputsourceid = RootSeqCxRbanaAnalyzerOneControl1Outputsourceid(self._context)
        self.filtaddr = RootSeqCxRbanaAnalyzerOneControl1Filtaddr(self._context)
        self.distdeltaf = RootSeqCxRbanaAnalyzerOneControl1Distdeltaf(self._context)
        self.fltr_vld = RootSeqCxRbanaAnalyzerOneControl1Fltr_vld(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.control1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.control1.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOneDisscp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one.disscp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzer.one.disscp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzer.one.disscp.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzerOne(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer.one'
        self.disscp = RootSeqCxRbanaAnalyzerOneDisscp(self._context)
        self.control1 = RootSeqCxRbanaAnalyzerOneControl1(self._context)
        self.centerfreq_lo = RootSeqCxRbanaAnalyzerOneCenterfreq_lo(self._context)
        self.deltafoffs_lo = RootSeqCxRbanaAnalyzerOneDeltafoffs_lo(self._context)
        self.setptampkel = RootSeqCxRbanaAnalyzerOneSetptampkel(self._context)
        self.phase = RootSeqCxRbanaAnalyzerOnePhase(self._context)
        self.y = RootSeqCxRbanaAnalyzerOneY(self._context)
        self.x = RootSeqCxRbanaAnalyzerOneX(self._context)
        self.deltaf = RootSeqCxRbanaAnalyzerOneDeltaf(self._context)
        self.kiphase = RootSeqCxRbanaAnalyzerOneKiphase(self._context)
        self.centerfreq_hi = RootSeqCxRbanaAnalyzerOneCenterfreq_hi(self._context)
        self.threshold = RootSeqCxRbanaAnalyzerOneThreshold(self._context)
        self.setvalampkel = RootSeqCxRbanaAnalyzerOneSetvalampkel(self._context)
        self.delaycomp = RootSeqCxRbanaAnalyzerOneDelaycomp(self._context)
        self.safetip = RootSeqCxRbanaAnalyzerOneSafetip(self._context)
        self.phaseshift = RootSeqCxRbanaAnalyzerOnePhaseshift(self._context)
        self.mode = RootSeqCxRbanaAnalyzerOneMode(self._context)
        self.amplitude = RootSeqCxRbanaAnalyzerOneAmplitude(self._context)
        self.modampkel = RootSeqCxRbanaAnalyzerOneModampkel(self._context)
        self.kpampkel = RootSeqCxRbanaAnalyzerOneKpampkel(self._context)
        self.kpphase = RootSeqCxRbanaAnalyzerOneKpphase(self._context)
        self.lockrangeshift = RootSeqCxRbanaAnalyzerOneLockrangeshift(self._context)
        self.ctrlbits = RootSeqCxRbanaAnalyzerOneCtrlbits(self._context)
        self.flag = RootSeqCxRbanaAnalyzerOneFlag(self._context)
        self.kiampkel = RootSeqCxRbanaAnalyzerOneKiampkel(self._context)
        self.fltrcoeff = RootSeqCxRbanaAnalyzerOneFltrcoeff(self._context)
        self.deltafoffs_hi = RootSeqCxRbanaAnalyzerOneDeltafoffs_hi(self._context)


class RootSeqCxRbanaAnalyzer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzer'
        self.one = RootSeqCxRbanaAnalyzerOne(self._context)
        self.two = RootSeqCxRbanaAnalyzerTwo(self._context)


class RootSeqCxRbanaAnalyzercommonSgleControlHarmoncinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzercommon.sgle.control.harmoncinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzercommon.sgle.control.harmoncinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzercommon.sgle.control.harmoncinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzercommon.sgle.control.harmoncinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzercommon.sgle.control.harmoncinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzercommon.sgle.control.harmoncinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzercommon.sgle.control.harmoncinput.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzercommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzercommon.sgle.control'
        self.harmoncinput = RootSeqCxRbanaAnalyzercommonSgleControlHarmoncinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.analyzercommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.analyzercommon.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaAnalyzercommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzercommon.sgle'
        self.control = RootSeqCxRbanaAnalyzercommonSgleControl(self._context)


class RootSeqCxRbanaAnalyzercommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.analyzercommon'
        self.sgle = RootSeqCxRbanaAnalyzercommonSgle(self._context)


class RootSeqCxRbanaGpiSgleOdata(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.odata'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.odata.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.odata.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqenaEventmgrstop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena.eventmgrstop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrstop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrstop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrstop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrstop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrstop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrstop.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqenaEventmgrabort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena.eventmgrabort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrabort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrabort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrabort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrabort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrabort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrabort.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqenaRampgentestdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena.rampgentestdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.rampgentestdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.rampgentestdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.rampgentestdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.rampgentestdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.rampgentestdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.rampgentestdone.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqenaUserdigi1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena.userdigi1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.userdigi1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.userdigi1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.userdigi1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.userdigi1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.userdigi1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.userdigi1.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqenaEventmgrdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena.eventmgrdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.eventmgrdone.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqenaRampgenuser4done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena.rampgenuser4done'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.rampgenuser4done.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.rampgenuser4done.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.rampgenuser4done.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.rampgenuser4done.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.rampgenuser4done.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.rampgenuser4done.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqenaUserdigi2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena.userdigi2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.userdigi2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.userdigi2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.userdigi2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.userdigi2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.userdigi2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.userdigi2.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqena'
        self.userdigi2 = RootSeqCxRbanaGpiSgleIrqenaUserdigi2(self._context)
        self.rampgenuser4done = RootSeqCxRbanaGpiSgleIrqenaRampgenuser4done(self._context)
        self.eventmgrdone = RootSeqCxRbanaGpiSgleIrqenaEventmgrdone(self._context)
        self.userdigi1 = RootSeqCxRbanaGpiSgleIrqenaUserdigi1(self._context)
        self.rampgentestdone = RootSeqCxRbanaGpiSgleIrqenaRampgentestdone(self._context)
        self.eventmgrabort = RootSeqCxRbanaGpiSgleIrqenaEventmgrabort(self._context)
        self.eventmgrstop = RootSeqCxRbanaGpiSgleIrqenaEventmgrstop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqena.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvecEventmgrstop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrstop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrstop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrstop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrstop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrstop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrstop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrstop.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvecEventmgrabort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrabort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrabort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrabort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrabort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrabort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrabort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrabort.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvecRampgentestdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec.rampgentestdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.rampgentestdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.rampgentestdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.rampgentestdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.rampgentestdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.rampgentestdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.rampgentestdone.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvecUserdigi1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec.userdigi1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi1.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvecEventmgrdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.eventmgrdone.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvecRampgenuser4done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec.rampgenuser4done'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.rampgenuser4done.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.rampgenuser4done.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.rampgenuser4done.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.rampgenuser4done.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.rampgenuser4done.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.rampgenuser4done.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvecUserdigi2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec.userdigi2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.userdigi2.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIrqvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.irqvec'
        self.userdigi2 = RootSeqCxRbanaGpiSgleIrqvecUserdigi2(self._context)
        self.rampgenuser4done = RootSeqCxRbanaGpiSgleIrqvecRampgenuser4done(self._context)
        self.eventmgrdone = RootSeqCxRbanaGpiSgleIrqvecEventmgrdone(self._context)
        self.userdigi1 = RootSeqCxRbanaGpiSgleIrqvecUserdigi1(self._context)
        self.rampgentestdone = RootSeqCxRbanaGpiSgleIrqvecRampgentestdone(self._context)
        self.eventmgrabort = RootSeqCxRbanaGpiSgleIrqvecEventmgrabort(self._context)
        self.eventmgrstop = RootSeqCxRbanaGpiSgleIrqvecEventmgrstop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.irqvec.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.irqvec.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdataEventmgrstop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata.eventmgrstop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrstop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrstop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrstop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrstop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrstop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrstop.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdataEventmgrabort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata.eventmgrabort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrabort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrabort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrabort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrabort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrabort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrabort.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdataRampgentestdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata.rampgentestdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.rampgentestdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.rampgentestdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.rampgentestdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.rampgentestdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.rampgentestdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.rampgentestdone.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdataUserdigi1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata.userdigi1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.userdigi1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.userdigi1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.userdigi1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.userdigi1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.userdigi1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.userdigi1.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdataEventmgrdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata.eventmgrdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.eventmgrdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.eventmgrdone.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdataRampgenuser4done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata.rampgenuser4done'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.rampgenuser4done.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.rampgenuser4done.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.rampgenuser4done.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.rampgenuser4done.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.rampgenuser4done.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.rampgenuser4done.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdataUserdigi2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata.userdigi2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.userdigi2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.userdigi2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.userdigi2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.userdigi2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.userdigi2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.userdigi2.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgleIdata(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle.idata'
        self.userdigi2 = RootSeqCxRbanaGpiSgleIdataUserdigi2(self._context)
        self.rampgenuser4done = RootSeqCxRbanaGpiSgleIdataRampgenuser4done(self._context)
        self.eventmgrdone = RootSeqCxRbanaGpiSgleIdataEventmgrdone(self._context)
        self.userdigi1 = RootSeqCxRbanaGpiSgleIdataUserdigi1(self._context)
        self.rampgentestdone = RootSeqCxRbanaGpiSgleIdataRampgentestdone(self._context)
        self.eventmgrabort = RootSeqCxRbanaGpiSgleIdataEventmgrabort(self._context)
        self.eventmgrstop = RootSeqCxRbanaGpiSgleIdataEventmgrstop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.gpi.sgle.idata.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.gpi.sgle.idata.regaddr', int(new_val))


class RootSeqCxRbanaGpiSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi.sgle'
        self.idata = RootSeqCxRbanaGpiSgleIdata(self._context)
        self.irqvec = RootSeqCxRbanaGpiSgleIrqvec(self._context)
        self.irqena = RootSeqCxRbanaGpiSgleIrqena(self._context)
        self.odata = RootSeqCxRbanaGpiSgleOdata(self._context)


class RootSeqCxRbanaGpi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.gpi'
        self.sgle = RootSeqCxRbanaGpiSgle(self._context)


class RootSeqCxRbanaSeqSgleA(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.a'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.a.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.a.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleSeqreg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.seqreg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.seqreg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.seqreg.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleBit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.bit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.bit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.bit.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleB(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.b'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.b.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.b.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleM(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.m'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.m.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.m.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleAddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.addr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.addr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.addr.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleInstrptr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.instrptr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.instrptr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.instrptr.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleControlStep(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.control.step'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.step.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.step.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.step.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.step.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.step.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.step.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.start.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.control'
        self.start = RootSeqCxRbanaSeqSgleControlStart(self._context)
        self.abort = RootSeqCxRbanaSeqSgleControlAbort(self._context)
        self.stop = RootSeqCxRbanaSeqSgleControlStop(self._context)
        self.step = RootSeqCxRbanaSeqSgleControlStep(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleStatusReaderror(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.status.readerror'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.status.readerror.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.status.readerror.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.status.readerror.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.status.readerror.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.status.readerror.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.status.readerror.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleStatusRunning(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.status.running'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.status.running.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.status.running.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.status.running.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.status.running.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.status.running.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.status.running.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.status'
        self.running = RootSeqCxRbanaSeqSgleStatusRunning(self._context)
        self.readerror = RootSeqCxRbanaSeqSgleStatusReaderror(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleSum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.sum'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.sum.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.sum.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgleData(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle.data'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.seq.sgle.data.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.seq.sgle.data.regaddr', int(new_val))


class RootSeqCxRbanaSeqSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq.sgle'
        self.data = RootSeqCxRbanaSeqSgleData(self._context)
        self.sum = RootSeqCxRbanaSeqSgleSum(self._context)
        self.status = RootSeqCxRbanaSeqSgleStatus(self._context)
        self.control = RootSeqCxRbanaSeqSgleControl(self._context)
        self.instrptr = RootSeqCxRbanaSeqSgleInstrptr(self._context)
        self.addr = RootSeqCxRbanaSeqSgleAddr(self._context)
        self.m = RootSeqCxRbanaSeqSgleM(self._context)
        self.b = RootSeqCxRbanaSeqSgleB(self._context)
        self.bit = RootSeqCxRbanaSeqSgleBit(self._context)
        self.seqreg = RootSeqCxRbanaSeqSgleSeqreg(self._context)
        self.a = RootSeqCxRbanaSeqSgleA(self._context)


class RootSeqCxRbanaSeq(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.seq'
        self.sgle = RootSeqCxRbanaSeqSgle(self._context)


class RootSeqCxRbanaZctrlexSgleCurrentrampvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.currentrampvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.currentrampvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.currentrampvalue.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleCurrentphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.currentphase'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.currentphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.currentphase.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleInputiirout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.inputiirout'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.inputiirout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.inputiirout.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP3movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p3movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p3movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p3movevalue.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP2moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p2moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p2moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p2moveinc.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleClp_pid_gain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_p.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleClp_pid_gain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_d.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleFb_pid_gain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_d.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleError(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.error'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.error.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.error.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP0moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p0moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p0moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p0moveinc.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleDdciiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.ddciiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.ddciiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.ddciiraddr.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSglePhase0realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.phase0realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.phase0realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.phase0realendpos.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSglePhase2realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.phase2realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.phase2realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.phase2realendpos.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleOutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.output'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.output.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.output.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSglePhase3realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.phase3realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.phase3realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.phase3realendpos.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleMinzvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.minzvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.minzvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.minzvalue.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSglePhase1realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.phase1realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.phase1realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.phase1realendpos.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzreachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusZctrlexrampgenmaxzdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusZctrlexactivaterunmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.zctrlexactivaterunmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusZctrlexreachedminz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedminz'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedminz.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedminz.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedminz.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedminz.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedminz.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedminz.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzbusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzbusy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzbusy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzbusy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzbusy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzbusy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzbusy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzbusy.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusZctrlexrampgenctrlzdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzreachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzcountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzcountup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzcountup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzcountup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzcountup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzcountup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzcountup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzcountup.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusZctrlexinternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.zctrlexinternaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexinternaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexinternaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexinternaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexinternaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexinternaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexinternaloaded.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzreachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusZctrlexreachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachederrlim.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusZctrlexreachedmaxz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedmaxz'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusStopwhileprocessing(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.stopwhileprocessing'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.stopwhileprocessing.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.stopwhileprocessing.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.stopwhileprocessing.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.stopwhileprocessing.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.stopwhileprocessing.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.stopwhileprocessing.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatusEndofphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status.endofphase'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.endofphase.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.endofphase.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.endofphase.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.endofphase.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.endofphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.endofphase.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.status'
        self.endofphase = RootSeqCxRbanaZctrlexSgleStatusEndofphase(self._context)
        self.stopwhileprocessing = RootSeqCxRbanaZctrlexSgleStatusStopwhileprocessing(self._context)
        self.zctrlexreachedmaxz = RootSeqCxRbanaZctrlexSgleStatusZctrlexreachedmaxz(self._context)
        self.zctrlexreachederrlim = RootSeqCxRbanaZctrlexSgleStatusZctrlexreachederrlim(self._context)
        self.rampgenctrlzreachedregularend = RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzreachedregularend(self._context)
        self.zctrlexinternaloaded = RootSeqCxRbanaZctrlexSgleStatusZctrlexinternaloaded(self._context)
        self.rampgenctrlzcountup = RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzcountup(self._context)
        self.rampgenctrlzreachedupperlimit = RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzreachedupperlimit(self._context)
        self.zctrlexrampgenctrlzdone = RootSeqCxRbanaZctrlexSgleStatusZctrlexrampgenctrlzdone(self._context)
        self.rampgenctrlzbusy = RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzbusy(self._context)
        self.zctrlexreachedminz = RootSeqCxRbanaZctrlexSgleStatusZctrlexreachedminz(self._context)
        self.zctrlexactivaterunmode = RootSeqCxRbanaZctrlexSgleStatusZctrlexactivaterunmode(self._context)
        self.zctrlexrampgenmaxzdone = RootSeqCxRbanaZctrlexSgleStatusZctrlexrampgenmaxzdone(self._context)
        self.rampgenctrlzreachedlowerlimit = RootSeqCxRbanaZctrlexSgleStatusRampgenctrlzreachedlowerlimit(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP2movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p2movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p2movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p2movevalue.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleFb_pid_gain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_p.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleTotphasenbr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.totphasenbr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.totphasenbr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.totphasenbr.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP0movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p0movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p0movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p0movevalue.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleZoutlimited(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.zoutlimited'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.zoutlimited.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.zoutlimited.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleRampgenctrlzout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzout'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzout.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P3workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p3workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3workmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P2movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P3movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P0movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P0workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p0workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0workmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P2workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p2workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2workmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P1workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p1workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1workmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P3moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p3moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p3moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p3moveendmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P1movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P0moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p0moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p0moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p0moveendmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P1moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p1moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p1moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p1moveendmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1P2moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1.p2moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.p2moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.p2moveendmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control1'
        self.p2moveendmode = RootSeqCxRbanaZctrlexSgleControl1P2moveendmode(self._context)
        self.p1moveendmode = RootSeqCxRbanaZctrlexSgleControl1P1moveendmode(self._context)
        self.p0moveendmode = RootSeqCxRbanaZctrlexSgleControl1P0moveendmode(self._context)
        self.p1movestopbyvalueactive = RootSeqCxRbanaZctrlexSgleControl1P1movestopbyvalueactive(self._context)
        self.p3moveendmode = RootSeqCxRbanaZctrlexSgleControl1P3moveendmode(self._context)
        self.p1workmode = RootSeqCxRbanaZctrlexSgleControl1P1workmode(self._context)
        self.p2workmode = RootSeqCxRbanaZctrlexSgleControl1P2workmode(self._context)
        self.p0workmode = RootSeqCxRbanaZctrlexSgleControl1P0workmode(self._context)
        self.p0movestopbyvalueactive = RootSeqCxRbanaZctrlexSgleControl1P0movestopbyvalueactive(self._context)
        self.p3movestopbyvalueactive = RootSeqCxRbanaZctrlexSgleControl1P3movestopbyvalueactive(self._context)
        self.p2movestopbyvalueactive = RootSeqCxRbanaZctrlexSgleControl1P2movestopbyvalueactive(self._context)
        self.p3workmode = RootSeqCxRbanaZctrlexSgleControl1P3workmode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control1.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.errorlimit.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSglePidcommand(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.pidcommand'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.pidcommand.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.pidcommand.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleRampgenctrlzlimitpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzlimitpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzlimitpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzlimitpos.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleDdciircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.ddciircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.ddciircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.ddciircoef.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP1moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p1moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p1moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p1moveinc.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleSum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.sum'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.sum.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.sum.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP3moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p3moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p3moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p3moveinc.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleInputiiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.inputiiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.inputiiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.inputiiraddr.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleCompdcwithz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.compdcwithz'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.compdcwithz.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.compdcwithz.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleFb_pid_gain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.fb_pid_gain_i.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.input'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.input.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.input.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleP1movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.p1movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.p1movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.p1movevalue.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleInputiircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.inputiircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.inputiircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.inputiircoef.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleRampgenctrlzlimitneg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzlimitneg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzlimitneg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.rampgenctrlzlimitneg.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleSetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.setpoint'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.setpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.setpoint.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleClp_pid_gain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.clp_pid_gain_i.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Stop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.stop.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Setpointmodulationena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.setpointmodulationena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.setpointmodulationena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.setpointmodulationena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.setpointmodulationena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.setpointmodulationena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.setpointmodulationena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.setpointmodulationena.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Zctrlexpolpidinzclp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Zctrlexpolpidinfb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Outputmodulationena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.outputmodulationena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.outputmodulationena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.outputmodulationena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.outputmodulationena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.outputmodulationena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.outputmodulationena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.outputmodulationena.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Zctrlexinputchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexinputchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexinputchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexinputchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexinputchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexinputchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexinputchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexinputchan.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Memorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.memorygendriveena.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Ddciir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.ddciir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.ddciir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.ddciir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.ddciir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.ddciir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.ddciir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.ddciir_vld.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Ddcdownsamplefactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.ddcdownsamplefactor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.ddcdownsamplefactor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.ddcdownsamplefactor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.ddcdownsamplefactor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.ddcdownsamplefactor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.ddcdownsamplefactor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.ddcdownsamplefactor.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Start(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.start.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Memorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.memorygenpositionena.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Inputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.inputiir_vld.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Zctrlexpolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Abort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.abort.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Zctrlexmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexmode.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0Zctrlexloadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexloadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexloadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexloadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexloadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexloadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexloadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.zctrlexloadinterna.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgleControl0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle.control0'
        self.zctrlexloadinterna = RootSeqCxRbanaZctrlexSgleControl0Zctrlexloadinterna(self._context)
        self.zctrlexmode = RootSeqCxRbanaZctrlexSgleControl0Zctrlexmode(self._context)
        self.abort = RootSeqCxRbanaZctrlexSgleControl0Abort(self._context)
        self.zctrlexpolcomperrlim = RootSeqCxRbanaZctrlexSgleControl0Zctrlexpolcomperrlim(self._context)
        self.inputiir_vld = RootSeqCxRbanaZctrlexSgleControl0Inputiir_vld(self._context)
        self.memorygenpositionena = RootSeqCxRbanaZctrlexSgleControl0Memorygenpositionena(self._context)
        self.start = RootSeqCxRbanaZctrlexSgleControl0Start(self._context)
        self.ddcdownsamplefactor = RootSeqCxRbanaZctrlexSgleControl0Ddcdownsamplefactor(self._context)
        self.ddciir_vld = RootSeqCxRbanaZctrlexSgleControl0Ddciir_vld(self._context)
        self.memorygendriveena = RootSeqCxRbanaZctrlexSgleControl0Memorygendriveena(self._context)
        self.zctrlexinputchan = RootSeqCxRbanaZctrlexSgleControl0Zctrlexinputchan(self._context)
        self.outputmodulationena = RootSeqCxRbanaZctrlexSgleControl0Outputmodulationena(self._context)
        self.zctrlexpolpidinfb = RootSeqCxRbanaZctrlexSgleControl0Zctrlexpolpidinfb(self._context)
        self.zctrlexpolpidinzclp = RootSeqCxRbanaZctrlexSgleControl0Zctrlexpolpidinzclp(self._context)
        self.setpointmodulationena = RootSeqCxRbanaZctrlexSgleControl0Setpointmodulationena(self._context)
        self.stop = RootSeqCxRbanaZctrlexSgleControl0Stop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.zctrlex.sgle.control0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.zctrlex.sgle.control0.regaddr', int(new_val))


class RootSeqCxRbanaZctrlexSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex.sgle'
        self.control0 = RootSeqCxRbanaZctrlexSgleControl0(self._context)
        self.clp_pid_gain_i = RootSeqCxRbanaZctrlexSgleClp_pid_gain_i(self._context)
        self.setpoint = RootSeqCxRbanaZctrlexSgleSetpoint(self._context)
        self.rampgenctrlzlimitneg = RootSeqCxRbanaZctrlexSgleRampgenctrlzlimitneg(self._context)
        self.inputiircoef = RootSeqCxRbanaZctrlexSgleInputiircoef(self._context)
        self.p1movevalue = RootSeqCxRbanaZctrlexSgleP1movevalue(self._context)
        self.input = RootSeqCxRbanaZctrlexSgleInput(self._context)
        self.fb_pid_gain_i = RootSeqCxRbanaZctrlexSgleFb_pid_gain_i(self._context)
        self.compdcwithz = RootSeqCxRbanaZctrlexSgleCompdcwithz(self._context)
        self.inputiiraddr = RootSeqCxRbanaZctrlexSgleInputiiraddr(self._context)
        self.p3moveinc = RootSeqCxRbanaZctrlexSgleP3moveinc(self._context)
        self.sum = RootSeqCxRbanaZctrlexSgleSum(self._context)
        self.p1moveinc = RootSeqCxRbanaZctrlexSgleP1moveinc(self._context)
        self.ddciircoef = RootSeqCxRbanaZctrlexSgleDdciircoef(self._context)
        self.rampgenctrlzlimitpos = RootSeqCxRbanaZctrlexSgleRampgenctrlzlimitpos(self._context)
        self.pidcommand = RootSeqCxRbanaZctrlexSglePidcommand(self._context)
        self.errorlimit = RootSeqCxRbanaZctrlexSgleErrorlimit(self._context)
        self.control1 = RootSeqCxRbanaZctrlexSgleControl1(self._context)
        self.rampgenctrlzout = RootSeqCxRbanaZctrlexSgleRampgenctrlzout(self._context)
        self.zoutlimited = RootSeqCxRbanaZctrlexSgleZoutlimited(self._context)
        self.p0movevalue = RootSeqCxRbanaZctrlexSgleP0movevalue(self._context)
        self.totphasenbr = RootSeqCxRbanaZctrlexSgleTotphasenbr(self._context)
        self.fb_pid_gain_p = RootSeqCxRbanaZctrlexSgleFb_pid_gain_p(self._context)
        self.p2movevalue = RootSeqCxRbanaZctrlexSgleP2movevalue(self._context)
        self.status = RootSeqCxRbanaZctrlexSgleStatus(self._context)
        self.phase1realendpos = RootSeqCxRbanaZctrlexSglePhase1realendpos(self._context)
        self.minzvalue = RootSeqCxRbanaZctrlexSgleMinzvalue(self._context)
        self.phase3realendpos = RootSeqCxRbanaZctrlexSglePhase3realendpos(self._context)
        self.output = RootSeqCxRbanaZctrlexSgleOutput(self._context)
        self.phase2realendpos = RootSeqCxRbanaZctrlexSglePhase2realendpos(self._context)
        self.phase0realendpos = RootSeqCxRbanaZctrlexSglePhase0realendpos(self._context)
        self.ddciiraddr = RootSeqCxRbanaZctrlexSgleDdciiraddr(self._context)
        self.p0moveinc = RootSeqCxRbanaZctrlexSgleP0moveinc(self._context)
        self.error = RootSeqCxRbanaZctrlexSgleError(self._context)
        self.fb_pid_gain_d = RootSeqCxRbanaZctrlexSgleFb_pid_gain_d(self._context)
        self.clp_pid_gain_d = RootSeqCxRbanaZctrlexSgleClp_pid_gain_d(self._context)
        self.clp_pid_gain_p = RootSeqCxRbanaZctrlexSgleClp_pid_gain_p(self._context)
        self.p2moveinc = RootSeqCxRbanaZctrlexSgleP2moveinc(self._context)
        self.p3movevalue = RootSeqCxRbanaZctrlexSgleP3movevalue(self._context)
        self.inputiirout = RootSeqCxRbanaZctrlexSgleInputiirout(self._context)
        self.currentphase = RootSeqCxRbanaZctrlexSgleCurrentphase(self._context)
        self.currentrampvalue = RootSeqCxRbanaZctrlexSgleCurrentrampvalue(self._context)


class RootSeqCxRbanaZctrlex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.zctrlex'
        self.sgle = RootSeqCxRbanaZctrlexSgle(self._context)


class RootSeqCxRbanaPidPidwStatusReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.status.reachedmax'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachedmax.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachedmax.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachedmax.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachedmax.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachedmax.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachedmax.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwStatusReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.status.reachedmin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachedmin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachedmin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachedmin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachedmin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachedmin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachedmin.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwStatusInternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.status.internaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.internaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.internaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.internaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.internaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.internaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.internaloaded.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwStatusReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.status.reachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.reachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.reachederrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.status'
        self.reachederrlim = RootSeqCxRbanaPidPidwStatusReachederrlim(self._context)
        self.internaloaded = RootSeqCxRbanaPidPidwStatusInternaloaded(self._context)
        self.reachedmin = RootSeqCxRbanaPidPidwStatusReachedmin(self._context)
        self.reachedmax = RootSeqCxRbanaPidPidwStatusReachedmax(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.status.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwGain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.gain_i.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwPreloadvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.preloadvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.preloadvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.preloadvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.minvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.offset.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.maxvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.maxvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.maxvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.slope'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.slope.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.slope.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlMemorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.memorygendriveena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlMemorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.memorygenpositionena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlModena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.modena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.modena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.modena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.modena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.modena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.modena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.modena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlOutsel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.outsel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.outsel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.outsel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.outsel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.outsel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.outsel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.outsel.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlPidinputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.pidinputsetpoint'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.pidinputsetpoint.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.pidinputsetpoint.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.pidinputsetpoint.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.pidinputsetpoint.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.pidinputsetpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.pidinputsetpoint.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlPidinputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.pidinputactual'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.pidinputactual.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.pidinputactual.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.pidinputactual.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.pidinputactual.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.pidinputactual.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.pidinputactual.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlPolpidin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.polpidin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.polpidin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.polpidin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.polpidin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.polpidin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.polpidin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.polpidin.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlPolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.polcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.polcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.polcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.polcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.polcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.polcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.polcomperrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlLoadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.loadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.loadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.loadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.loadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.loadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.loadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.loadinterna.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControlMedianfilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control.medianfilterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.medianfilterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.medianfilterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.medianfilterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.medianfilterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.medianfilterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.medianfilterena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.control'
        self.medianfilterena = RootSeqCxRbanaPidPidwControlMedianfilterena(self._context)
        self.loadinterna = RootSeqCxRbanaPidPidwControlLoadinterna(self._context)
        self.polcomperrlim = RootSeqCxRbanaPidPidwControlPolcomperrlim(self._context)
        self.polpidin = RootSeqCxRbanaPidPidwControlPolpidin(self._context)
        self.pidinputactual = RootSeqCxRbanaPidPidwControlPidinputactual(self._context)
        self.mode = RootSeqCxRbanaPidPidwControlMode(self._context)
        self.pidinputsetpoint = RootSeqCxRbanaPidPidwControlPidinputsetpoint(self._context)
        self.outsel = RootSeqCxRbanaPidPidwControlOutsel(self._context)
        self.modena = RootSeqCxRbanaPidPidwControlModena(self._context)
        self.memorygenpositionena = RootSeqCxRbanaPidPidwControlMemorygenpositionena(self._context)
        self.memorygendriveena = RootSeqCxRbanaPidPidwControlMemorygendriveena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.control.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwGain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.gain_d.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwGain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.gain_p.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwConversion(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.conversion'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.conversion.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.conversion.regaddr', int(new_val))


class RootSeqCxRbanaPidPidwErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidw.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidw.errorlimit.regaddr', int(new_val))


class RootSeqCxRbanaPidPidw(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidw'
        self.errorlimit = RootSeqCxRbanaPidPidwErrorlimit(self._context)
        self.conversion = RootSeqCxRbanaPidPidwConversion(self._context)
        self.gain_p = RootSeqCxRbanaPidPidwGain_p(self._context)
        self.gain_d = RootSeqCxRbanaPidPidwGain_d(self._context)
        self.control = RootSeqCxRbanaPidPidwControl(self._context)
        self.slope = RootSeqCxRbanaPidPidwSlope(self._context)
        self.maxvalue = RootSeqCxRbanaPidPidwMaxvalue(self._context)
        self.offset = RootSeqCxRbanaPidPidwOffset(self._context)
        self.minvalue = RootSeqCxRbanaPidPidwMinvalue(self._context)
        self.preloadvalue = RootSeqCxRbanaPidPidwPreloadvalue(self._context)
        self.gain_i = RootSeqCxRbanaPidPidwGain_i(self._context)
        self.status = RootSeqCxRbanaPidPidwStatus(self._context)


class RootSeqCxRbanaPidPidyStatusReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.status.reachedmax'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachedmax.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachedmax.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachedmax.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachedmax.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachedmax.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachedmax.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyStatusReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.status.reachedmin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachedmin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachedmin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachedmin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachedmin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachedmin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachedmin.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyStatusInternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.status.internaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.internaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.internaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.internaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.internaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.internaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.internaloaded.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyStatusReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.status.reachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.reachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.reachederrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.status'
        self.reachederrlim = RootSeqCxRbanaPidPidyStatusReachederrlim(self._context)
        self.internaloaded = RootSeqCxRbanaPidPidyStatusInternaloaded(self._context)
        self.reachedmin = RootSeqCxRbanaPidPidyStatusReachedmin(self._context)
        self.reachedmax = RootSeqCxRbanaPidPidyStatusReachedmax(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.status.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyGain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.gain_i.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyPreloadvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.preloadvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.preloadvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.preloadvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.minvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.offset.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.maxvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.maxvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.maxvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidySlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.slope'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.slope.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.slope.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlMemorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.memorygendriveena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlMemorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.memorygenpositionena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlModena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.modena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.modena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.modena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.modena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.modena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.modena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.modena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlOutsel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.outsel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.outsel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.outsel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.outsel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.outsel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.outsel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.outsel.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlPidinputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.pidinputsetpoint'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.pidinputsetpoint.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.pidinputsetpoint.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.pidinputsetpoint.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.pidinputsetpoint.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.pidinputsetpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.pidinputsetpoint.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlPidinputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.pidinputactual'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.pidinputactual.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.pidinputactual.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.pidinputactual.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.pidinputactual.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.pidinputactual.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.pidinputactual.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlPolpidin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.polpidin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.polpidin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.polpidin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.polpidin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.polpidin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.polpidin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.polpidin.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlPolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.polcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.polcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.polcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.polcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.polcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.polcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.polcomperrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlLoadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.loadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.loadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.loadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.loadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.loadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.loadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.loadinterna.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControlMedianfilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control.medianfilterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.medianfilterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.medianfilterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.medianfilterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.medianfilterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.medianfilterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.medianfilterena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.control'
        self.medianfilterena = RootSeqCxRbanaPidPidyControlMedianfilterena(self._context)
        self.loadinterna = RootSeqCxRbanaPidPidyControlLoadinterna(self._context)
        self.polcomperrlim = RootSeqCxRbanaPidPidyControlPolcomperrlim(self._context)
        self.polpidin = RootSeqCxRbanaPidPidyControlPolpidin(self._context)
        self.pidinputactual = RootSeqCxRbanaPidPidyControlPidinputactual(self._context)
        self.mode = RootSeqCxRbanaPidPidyControlMode(self._context)
        self.pidinputsetpoint = RootSeqCxRbanaPidPidyControlPidinputsetpoint(self._context)
        self.outsel = RootSeqCxRbanaPidPidyControlOutsel(self._context)
        self.modena = RootSeqCxRbanaPidPidyControlModena(self._context)
        self.memorygenpositionena = RootSeqCxRbanaPidPidyControlMemorygenpositionena(self._context)
        self.memorygendriveena = RootSeqCxRbanaPidPidyControlMemorygendriveena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.control.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyGain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.gain_d.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyGain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.gain_p.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyConversion(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.conversion'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.conversion.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.conversion.regaddr', int(new_val))


class RootSeqCxRbanaPidPidyErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidy.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidy.errorlimit.regaddr', int(new_val))


class RootSeqCxRbanaPidPidy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidy'
        self.errorlimit = RootSeqCxRbanaPidPidyErrorlimit(self._context)
        self.conversion = RootSeqCxRbanaPidPidyConversion(self._context)
        self.gain_p = RootSeqCxRbanaPidPidyGain_p(self._context)
        self.gain_d = RootSeqCxRbanaPidPidyGain_d(self._context)
        self.control = RootSeqCxRbanaPidPidyControl(self._context)
        self.slope = RootSeqCxRbanaPidPidySlope(self._context)
        self.maxvalue = RootSeqCxRbanaPidPidyMaxvalue(self._context)
        self.offset = RootSeqCxRbanaPidPidyOffset(self._context)
        self.minvalue = RootSeqCxRbanaPidPidyMinvalue(self._context)
        self.preloadvalue = RootSeqCxRbanaPidPidyPreloadvalue(self._context)
        self.gain_i = RootSeqCxRbanaPidPidyGain_i(self._context)
        self.status = RootSeqCxRbanaPidPidyStatus(self._context)


class RootSeqCxRbanaPidPidxStatusReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.status.reachedmax'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachedmax.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachedmax.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachedmax.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachedmax.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachedmax.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachedmax.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxStatusReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.status.reachedmin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachedmin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachedmin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachedmin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachedmin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachedmin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachedmin.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxStatusInternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.status.internaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.internaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.internaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.internaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.internaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.internaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.internaloaded.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxStatusReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.status.reachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.reachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.reachederrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.status'
        self.reachederrlim = RootSeqCxRbanaPidPidxStatusReachederrlim(self._context)
        self.internaloaded = RootSeqCxRbanaPidPidxStatusInternaloaded(self._context)
        self.reachedmin = RootSeqCxRbanaPidPidxStatusReachedmin(self._context)
        self.reachedmax = RootSeqCxRbanaPidPidxStatusReachedmax(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.status.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxGain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.gain_i.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxPreloadvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.preloadvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.preloadvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.preloadvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.minvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.offset.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.maxvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.maxvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.maxvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.slope'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.slope.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.slope.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlMemorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.memorygendriveena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlMemorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.memorygenpositionena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlModena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.modena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.modena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.modena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.modena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.modena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.modena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.modena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlOutsel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.outsel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.outsel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.outsel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.outsel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.outsel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.outsel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.outsel.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlPidinputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.pidinputsetpoint'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.pidinputsetpoint.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.pidinputsetpoint.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.pidinputsetpoint.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.pidinputsetpoint.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.pidinputsetpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.pidinputsetpoint.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlPidinputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.pidinputactual'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.pidinputactual.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.pidinputactual.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.pidinputactual.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.pidinputactual.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.pidinputactual.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.pidinputactual.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlPolpidin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.polpidin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.polpidin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.polpidin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.polpidin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.polpidin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.polpidin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.polpidin.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlPolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.polcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.polcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.polcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.polcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.polcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.polcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.polcomperrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlLoadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.loadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.loadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.loadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.loadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.loadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.loadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.loadinterna.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControlMedianfilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control.medianfilterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.medianfilterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.medianfilterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.medianfilterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.medianfilterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.medianfilterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.medianfilterena.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.control'
        self.medianfilterena = RootSeqCxRbanaPidPidxControlMedianfilterena(self._context)
        self.loadinterna = RootSeqCxRbanaPidPidxControlLoadinterna(self._context)
        self.polcomperrlim = RootSeqCxRbanaPidPidxControlPolcomperrlim(self._context)
        self.polpidin = RootSeqCxRbanaPidPidxControlPolpidin(self._context)
        self.pidinputactual = RootSeqCxRbanaPidPidxControlPidinputactual(self._context)
        self.mode = RootSeqCxRbanaPidPidxControlMode(self._context)
        self.pidinputsetpoint = RootSeqCxRbanaPidPidxControlPidinputsetpoint(self._context)
        self.outsel = RootSeqCxRbanaPidPidxControlOutsel(self._context)
        self.modena = RootSeqCxRbanaPidPidxControlModena(self._context)
        self.memorygenpositionena = RootSeqCxRbanaPidPidxControlMemorygenpositionena(self._context)
        self.memorygendriveena = RootSeqCxRbanaPidPidxControlMemorygendriveena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.control.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxGain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.gain_d.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxGain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.gain_p.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxConversion(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.conversion'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.conversion.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.conversion.regaddr', int(new_val))


class RootSeqCxRbanaPidPidxErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.pidx.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.pidx.errorlimit.regaddr', int(new_val))


class RootSeqCxRbanaPidPidx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.pidx'
        self.errorlimit = RootSeqCxRbanaPidPidxErrorlimit(self._context)
        self.conversion = RootSeqCxRbanaPidPidxConversion(self._context)
        self.gain_p = RootSeqCxRbanaPidPidxGain_p(self._context)
        self.gain_d = RootSeqCxRbanaPidPidxGain_d(self._context)
        self.control = RootSeqCxRbanaPidPidxControl(self._context)
        self.slope = RootSeqCxRbanaPidPidxSlope(self._context)
        self.maxvalue = RootSeqCxRbanaPidPidxMaxvalue(self._context)
        self.offset = RootSeqCxRbanaPidPidxOffset(self._context)
        self.minvalue = RootSeqCxRbanaPidPidxMinvalue(self._context)
        self.preloadvalue = RootSeqCxRbanaPidPidxPreloadvalue(self._context)
        self.gain_i = RootSeqCxRbanaPidPidxGain_i(self._context)
        self.status = RootSeqCxRbanaPidPidxStatus(self._context)


class RootSeqCxRbanaPidPiduser2StatusReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.status.reachedmax'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachedmax.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachedmax.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachedmax.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachedmax.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachedmax.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachedmax.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2StatusReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.status.reachedmin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachedmin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachedmin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachedmin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachedmin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachedmin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachedmin.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2StatusInternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.status.internaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.internaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.internaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.internaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.internaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.internaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.internaloaded.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2StatusReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.status.reachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.reachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.reachederrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.status'
        self.reachederrlim = RootSeqCxRbanaPidPiduser2StatusReachederrlim(self._context)
        self.internaloaded = RootSeqCxRbanaPidPiduser2StatusInternaloaded(self._context)
        self.reachedmin = RootSeqCxRbanaPidPiduser2StatusReachedmin(self._context)
        self.reachedmax = RootSeqCxRbanaPidPiduser2StatusReachedmax(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.status.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Gain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.gain_i.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Preloadvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.preloadvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.preloadvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.preloadvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Minvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.minvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.offset.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Maxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.maxvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.maxvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.maxvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Slope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.slope'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.slope.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.slope.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlMemorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.memorygendriveena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlMemorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.memorygenpositionena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlModena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.modena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.modena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.modena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.modena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.modena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.modena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.modena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlOutsel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.outsel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.outsel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.outsel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.outsel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.outsel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.outsel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.outsel.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlPidinputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.pidinputsetpoint'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.pidinputsetpoint.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.pidinputsetpoint.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.pidinputsetpoint.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.pidinputsetpoint.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.pidinputsetpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.pidinputsetpoint.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlPidinputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.pidinputactual'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.pidinputactual.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.pidinputactual.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.pidinputactual.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.pidinputactual.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.pidinputactual.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.pidinputactual.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlPolpidin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.polpidin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.polpidin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.polpidin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.polpidin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.polpidin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.polpidin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.polpidin.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlPolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.polcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.polcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.polcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.polcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.polcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.polcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.polcomperrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlLoadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.loadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.loadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.loadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.loadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.loadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.loadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.loadinterna.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2ControlMedianfilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control.medianfilterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.medianfilterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.medianfilterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.medianfilterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.medianfilterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.medianfilterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.medianfilterena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.control'
        self.medianfilterena = RootSeqCxRbanaPidPiduser2ControlMedianfilterena(self._context)
        self.loadinterna = RootSeqCxRbanaPidPiduser2ControlLoadinterna(self._context)
        self.polcomperrlim = RootSeqCxRbanaPidPiduser2ControlPolcomperrlim(self._context)
        self.polpidin = RootSeqCxRbanaPidPiduser2ControlPolpidin(self._context)
        self.pidinputactual = RootSeqCxRbanaPidPiduser2ControlPidinputactual(self._context)
        self.mode = RootSeqCxRbanaPidPiduser2ControlMode(self._context)
        self.pidinputsetpoint = RootSeqCxRbanaPidPiduser2ControlPidinputsetpoint(self._context)
        self.outsel = RootSeqCxRbanaPidPiduser2ControlOutsel(self._context)
        self.modena = RootSeqCxRbanaPidPiduser2ControlModena(self._context)
        self.memorygenpositionena = RootSeqCxRbanaPidPiduser2ControlMemorygenpositionena(self._context)
        self.memorygendriveena = RootSeqCxRbanaPidPiduser2ControlMemorygendriveena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.control.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Gain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.gain_d.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Gain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.gain_p.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Conversion(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.conversion'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.conversion.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.conversion.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2Errorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser2.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser2.errorlimit.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser2'
        self.errorlimit = RootSeqCxRbanaPidPiduser2Errorlimit(self._context)
        self.conversion = RootSeqCxRbanaPidPiduser2Conversion(self._context)
        self.gain_p = RootSeqCxRbanaPidPiduser2Gain_p(self._context)
        self.gain_d = RootSeqCxRbanaPidPiduser2Gain_d(self._context)
        self.control = RootSeqCxRbanaPidPiduser2Control(self._context)
        self.slope = RootSeqCxRbanaPidPiduser2Slope(self._context)
        self.maxvalue = RootSeqCxRbanaPidPiduser2Maxvalue(self._context)
        self.offset = RootSeqCxRbanaPidPiduser2Offset(self._context)
        self.minvalue = RootSeqCxRbanaPidPiduser2Minvalue(self._context)
        self.preloadvalue = RootSeqCxRbanaPidPiduser2Preloadvalue(self._context)
        self.gain_i = RootSeqCxRbanaPidPiduser2Gain_i(self._context)
        self.status = RootSeqCxRbanaPidPiduser2Status(self._context)


class RootSeqCxRbanaPidPiduser1StatusReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.status.reachedmax'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachedmax.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachedmax.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachedmax.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachedmax.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachedmax.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachedmax.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1StatusReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.status.reachedmin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachedmin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachedmin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachedmin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachedmin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachedmin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachedmin.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1StatusInternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.status.internaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.internaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.internaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.internaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.internaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.internaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.internaloaded.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1StatusReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.status.reachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.reachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.reachederrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.status'
        self.reachederrlim = RootSeqCxRbanaPidPiduser1StatusReachederrlim(self._context)
        self.internaloaded = RootSeqCxRbanaPidPiduser1StatusInternaloaded(self._context)
        self.reachedmin = RootSeqCxRbanaPidPiduser1StatusReachedmin(self._context)
        self.reachedmax = RootSeqCxRbanaPidPiduser1StatusReachedmax(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.status.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Gain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.gain_i.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Preloadvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.preloadvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.preloadvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.preloadvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Minvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.minvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.offset.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Maxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.maxvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.maxvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.maxvalue.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Slope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.slope'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.slope.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.slope.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlMemorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.memorygendriveena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlMemorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.memorygenpositionena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlModena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.modena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.modena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.modena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.modena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.modena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.modena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.modena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlOutsel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.outsel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.outsel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.outsel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.outsel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.outsel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.outsel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.outsel.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlPidinputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.pidinputsetpoint'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.pidinputsetpoint.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.pidinputsetpoint.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.pidinputsetpoint.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.pidinputsetpoint.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.pidinputsetpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.pidinputsetpoint.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlPidinputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.pidinputactual'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.pidinputactual.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.pidinputactual.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.pidinputactual.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.pidinputactual.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.pidinputactual.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.pidinputactual.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlPolpidin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.polpidin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.polpidin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.polpidin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.polpidin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.polpidin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.polpidin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.polpidin.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlPolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.polcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.polcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.polcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.polcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.polcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.polcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.polcomperrlim.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlLoadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.loadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.loadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.loadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.loadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.loadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.loadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.loadinterna.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1ControlMedianfilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control.medianfilterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.medianfilterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.medianfilterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.medianfilterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.medianfilterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.medianfilterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.medianfilterena.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.control'
        self.medianfilterena = RootSeqCxRbanaPidPiduser1ControlMedianfilterena(self._context)
        self.loadinterna = RootSeqCxRbanaPidPiduser1ControlLoadinterna(self._context)
        self.polcomperrlim = RootSeqCxRbanaPidPiduser1ControlPolcomperrlim(self._context)
        self.polpidin = RootSeqCxRbanaPidPiduser1ControlPolpidin(self._context)
        self.pidinputactual = RootSeqCxRbanaPidPiduser1ControlPidinputactual(self._context)
        self.mode = RootSeqCxRbanaPidPiduser1ControlMode(self._context)
        self.pidinputsetpoint = RootSeqCxRbanaPidPiduser1ControlPidinputsetpoint(self._context)
        self.outsel = RootSeqCxRbanaPidPiduser1ControlOutsel(self._context)
        self.modena = RootSeqCxRbanaPidPiduser1ControlModena(self._context)
        self.memorygenpositionena = RootSeqCxRbanaPidPiduser1ControlMemorygenpositionena(self._context)
        self.memorygendriveena = RootSeqCxRbanaPidPiduser1ControlMemorygendriveena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.control.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Gain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.gain_d.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Gain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.gain_p.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Conversion(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.conversion'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.conversion.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.conversion.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1Errorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.pid.piduser1.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.pid.piduser1.errorlimit.regaddr', int(new_val))


class RootSeqCxRbanaPidPiduser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid.piduser1'
        self.errorlimit = RootSeqCxRbanaPidPiduser1Errorlimit(self._context)
        self.conversion = RootSeqCxRbanaPidPiduser1Conversion(self._context)
        self.gain_p = RootSeqCxRbanaPidPiduser1Gain_p(self._context)
        self.gain_d = RootSeqCxRbanaPidPiduser1Gain_d(self._context)
        self.control = RootSeqCxRbanaPidPiduser1Control(self._context)
        self.slope = RootSeqCxRbanaPidPiduser1Slope(self._context)
        self.maxvalue = RootSeqCxRbanaPidPiduser1Maxvalue(self._context)
        self.offset = RootSeqCxRbanaPidPiduser1Offset(self._context)
        self.minvalue = RootSeqCxRbanaPidPiduser1Minvalue(self._context)
        self.preloadvalue = RootSeqCxRbanaPidPiduser1Preloadvalue(self._context)
        self.gain_i = RootSeqCxRbanaPidPiduser1Gain_i(self._context)
        self.status = RootSeqCxRbanaPidPiduser1Status(self._context)


class RootSeqCxRbanaPid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.pid'
        self.piduser1 = RootSeqCxRbanaPidPiduser1(self._context)
        self.piduser2 = RootSeqCxRbanaPidPiduser2(self._context)
        self.pidx = RootSeqCxRbanaPidPidx(self._context)
        self.pidy = RootSeqCxRbanaPidPidy(self._context)
        self.pidw = RootSeqCxRbanaPidPidw(self._context)


class RootSeqCxRbanaRegaddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.regaddr'


class RootSeqCxRbanaDatasamplerSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleStatusEventcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.status.eventcount'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.status.eventcount.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.status.eventcount.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.status.eventcount.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.status.eventcount.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.status.eventcount.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.status.eventcount.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.status'
        self.eventcount = RootSeqCxRbanaDatasamplerSgleStatusEventcount(self._context)
        self.busy = RootSeqCxRbanaDatasamplerSgleStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleDatapoint0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.datapoint0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.datapoint0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.datapoint0.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleDatapoint3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.datapoint3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.datapoint3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.datapoint3.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleValue2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.value2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.value2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.value2.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleEvents(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.events'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.events.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.events.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleTimestamplastlsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.timestamplastlsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.timestamplastlsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.timestamplastlsb.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleDatapoint2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.datapoint2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.datapoint2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.datapoint2.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleControlSyncwithzctrlex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.control.syncwithzctrlex'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.syncwithzctrlex.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.syncwithzctrlex.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.syncwithzctrlex.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.syncwithzctrlex.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.syncwithzctrlex.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.syncwithzctrlex.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleControlFlushfifo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.control.flushfifo'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.flushfifo.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.flushfifo.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.flushfifo.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.flushfifo.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.flushfifo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.flushfifo.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.start.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.control'
        self.start = RootSeqCxRbanaDatasamplerSgleControlStart(self._context)
        self.flushfifo = RootSeqCxRbanaDatasamplerSgleControlFlushfifo(self._context)
        self.abort = RootSeqCxRbanaDatasamplerSgleControlAbort(self._context)
        self.stop = RootSeqCxRbanaDatasamplerSgleControlStop(self._context)
        self.mode = RootSeqCxRbanaDatasamplerSgleControlMode(self._context)
        self.syncwithzctrlex = RootSeqCxRbanaDatasamplerSgleControlSyncwithzctrlex(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleTimestampfirstmsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.timestampfirstmsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.timestampfirstmsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.timestampfirstmsb.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleTimestamplastmsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.timestamplastmsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.timestamplastmsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.timestamplastmsb.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleValue0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.value0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.value0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.value0.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleValue1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.value1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.value1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.value1.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSglePhasenbr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.phasenbr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.phasenbr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.phasenbr.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleTimestampfirstlsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.timestampfirstlsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.timestampfirstlsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.timestampfirstlsb.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleDatapoint1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.datapoint1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.datapoint1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.datapoint1.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgleValue3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle.value3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datasampler.sgle.value3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datasampler.sgle.value3.regaddr', int(new_val))


class RootSeqCxRbanaDatasamplerSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler.sgle'
        self.value3 = RootSeqCxRbanaDatasamplerSgleValue3(self._context)
        self.datapoint1 = RootSeqCxRbanaDatasamplerSgleDatapoint1(self._context)
        self.timestampfirstlsb = RootSeqCxRbanaDatasamplerSgleTimestampfirstlsb(self._context)
        self.phasenbr = RootSeqCxRbanaDatasamplerSglePhasenbr(self._context)
        self.value1 = RootSeqCxRbanaDatasamplerSgleValue1(self._context)
        self.value0 = RootSeqCxRbanaDatasamplerSgleValue0(self._context)
        self.timestamplastmsb = RootSeqCxRbanaDatasamplerSgleTimestamplastmsb(self._context)
        self.timestampfirstmsb = RootSeqCxRbanaDatasamplerSgleTimestampfirstmsb(self._context)
        self.control = RootSeqCxRbanaDatasamplerSgleControl(self._context)
        self.datapoint2 = RootSeqCxRbanaDatasamplerSgleDatapoint2(self._context)
        self.timestamplastlsb = RootSeqCxRbanaDatasamplerSgleTimestamplastlsb(self._context)
        self.events = RootSeqCxRbanaDatasamplerSgleEvents(self._context)
        self.value2 = RootSeqCxRbanaDatasamplerSgleValue2(self._context)
        self.datapoint3 = RootSeqCxRbanaDatasamplerSgleDatapoint3(self._context)
        self.datapoint0 = RootSeqCxRbanaDatasamplerSgleDatapoint0(self._context)
        self.status = RootSeqCxRbanaDatasamplerSgleStatus(self._context)


class RootSeqCxRbanaDatasampler(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datasampler'
        self.sgle = RootSeqCxRbanaDatasamplerSgle(self._context)


class RootSeqCxRbanaTimerProc0Events(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.events'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.events.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.events.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0StatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0StatusEventcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.status.eventcount'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.status.eventcount.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.status.eventcount.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.status.eventcount.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.status.eventcount.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.status.eventcount.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.status.eventcount.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.status'
        self.eventcount = RootSeqCxRbanaTimerProc0StatusEventcount(self._context)
        self.busy = RootSeqCxRbanaTimerProc0StatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.status.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0Value(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.value.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0ControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0ControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0ControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.start.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0.control'
        self.start = RootSeqCxRbanaTimerProc0ControlStart(self._context)
        self.abort = RootSeqCxRbanaTimerProc0ControlAbort(self._context)
        self.stop = RootSeqCxRbanaTimerProc0ControlStop(self._context)
        self.mode = RootSeqCxRbanaTimerProc0ControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.proc0.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.proc0.control.regaddr', int(new_val))


class RootSeqCxRbanaTimerProc0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.proc0'
        self.control = RootSeqCxRbanaTimerProc0Control(self._context)
        self.value = RootSeqCxRbanaTimerProc0Value(self._context)
        self.status = RootSeqCxRbanaTimerProc0Status(self._context)
        self.events = RootSeqCxRbanaTimerProc0Events(self._context)


class RootSeqCxRbanaTimerDbg1Events(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.events'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.events.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.events.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1StatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1StatusEventcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.status.eventcount'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.status.eventcount.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.status.eventcount.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.status.eventcount.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.status.eventcount.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.status.eventcount.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.status.eventcount.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.status'
        self.eventcount = RootSeqCxRbanaTimerDbg1StatusEventcount(self._context)
        self.busy = RootSeqCxRbanaTimerDbg1StatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.status.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1Value(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.value.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.mode.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1ControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1ControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1ControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.start.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1.control'
        self.start = RootSeqCxRbanaTimerDbg1ControlStart(self._context)
        self.abort = RootSeqCxRbanaTimerDbg1ControlAbort(self._context)
        self.stop = RootSeqCxRbanaTimerDbg1ControlStop(self._context)
        self.mode = RootSeqCxRbanaTimerDbg1ControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.timer.dbg1.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.timer.dbg1.control.regaddr', int(new_val))


class RootSeqCxRbanaTimerDbg1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer.dbg1'
        self.control = RootSeqCxRbanaTimerDbg1Control(self._context)
        self.value = RootSeqCxRbanaTimerDbg1Value(self._context)
        self.status = RootSeqCxRbanaTimerDbg1Status(self._context)
        self.events = RootSeqCxRbanaTimerDbg1Events(self._context)


class RootSeqCxRbanaTimer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.timer'
        self.dbg1 = RootSeqCxRbanaTimerDbg1(self._context)
        self.proc0 = RootSeqCxRbanaTimerProc0(self._context)


class RootSeqCxRbanaDpointfltrSgleStatusFifolevel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.status.fifolevel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifolevel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifolevel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifolevel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifolevel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifolevel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifolevel.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleStatusFifofullflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.status.fifofullflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifofullflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifofullflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifofullflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifofullflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifofullflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifofullflag.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleStatusFifoemptyflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.status.fifoemptyflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifoemptyflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifoemptyflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifoemptyflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifoemptyflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.fifoemptyflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.fifoemptyflag.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleStatusAcqdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.status.acqdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.acqdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.acqdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.acqdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.acqdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.acqdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.acqdone.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleStatusAcqinprogress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.status.acqinprogress'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.acqinprogress.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.acqinprogress.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.acqinprogress.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.acqinprogress.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.acqinprogress.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.acqinprogress.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.status'
        self.acqinprogress = RootSeqCxRbanaDpointfltrSgleStatusAcqinprogress(self._context)
        self.acqdone = RootSeqCxRbanaDpointfltrSgleStatusAcqdone(self._context)
        self.fifoemptyflag = RootSeqCxRbanaDpointfltrSgleStatusFifoemptyflag(self._context)
        self.fifofullflag = RootSeqCxRbanaDpointfltrSgleStatusFifofullflag(self._context)
        self.fifolevel = RootSeqCxRbanaDpointfltrSgleStatusFifolevel(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin12Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin12.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin12.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin12.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin12.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin12.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin12.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin12.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin12(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin12'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin12Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin12.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin12.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin4Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin4.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin4.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin4.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin4.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin4.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin4.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin4.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin4'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin4Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin4.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin8Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin8.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin8.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin8.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin8.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin8.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin8.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin8.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin8(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin8'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin8Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin8.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin8.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin9Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin9.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin9.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin9.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin9.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin9.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin9.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin9.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin9(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin9'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin9Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin9.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin9.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin13Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin13.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin13.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin13.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin13.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin13.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin13.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin13.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin13(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin13'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin13Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin13.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin13.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin10Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin10.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin10.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin10.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin10.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin10.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin10.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin10.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin10(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin10'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin10Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin10.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin10.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleControlFilterstage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.control.filterstage'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.control.filterstage.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.control.filterstage.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.control.filterstage.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.control.filterstage.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.control.filterstage.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.control.filterstage.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleControlSamplemask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.control.samplemask'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.control.samplemask.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.control.samplemask.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.control.samplemask.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.control.samplemask.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.control.samplemask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.control.samplemask.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.control'
        self.samplemask = RootSeqCxRbanaDpointfltrSgleControlSamplemask(self._context)
        self.filterstage = RootSeqCxRbanaDpointfltrSgleControlFilterstage(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin6Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin6.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin6.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin6.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin6.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin6.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin6.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin6.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin6'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin6Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin6.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin6.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin14Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin14.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin14.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin14.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin14.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin14.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin14.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin14.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin14(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin14'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin14Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin14.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin14.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin2Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin2.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin2.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin2.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin2.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin2.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin2.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin2.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin2'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin2Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin2.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleFircoeffs(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.fircoeffs'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.fircoeffs.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.fircoeffs.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin3Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin3.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin3.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin3.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin3.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin3.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin3.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin3.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin3'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin3Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin3.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin0Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin0.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin0.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin0.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin0.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin0.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin0.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin0.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin0'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin0Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin0.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin15Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin15.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin15.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin15.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin15.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin15.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin15.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin15.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin15(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin15'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin15Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin15.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin15.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin1Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin1.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin1.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin1.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin1.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin1.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin1.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin1.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin1'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin1Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin1.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin11Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin11.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin11.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin11.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin11.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin11.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin11.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin11.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin11(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin11'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin11Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin11.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin11.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin5Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin5.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin5.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin5.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin5.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin5.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin5.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin5.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin5'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin5Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin5.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin5.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleData(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.data'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.data.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.data.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin7Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin7.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin7.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin7.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin7.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin7.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin7.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin7.srcchan.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgleChanin7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle.chanin7'
        self.srcchan = RootSeqCxRbanaDpointfltrSgleChanin7Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.dpointfltr.sgle.chanin7.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.dpointfltr.sgle.chanin7.regaddr', int(new_val))


class RootSeqCxRbanaDpointfltrSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr.sgle'
        self.chanin7 = RootSeqCxRbanaDpointfltrSgleChanin7(self._context)
        self.data = RootSeqCxRbanaDpointfltrSgleData(self._context)
        self.chanin5 = RootSeqCxRbanaDpointfltrSgleChanin5(self._context)
        self.chanin11 = RootSeqCxRbanaDpointfltrSgleChanin11(self._context)
        self.chanin1 = RootSeqCxRbanaDpointfltrSgleChanin1(self._context)
        self.chanin15 = RootSeqCxRbanaDpointfltrSgleChanin15(self._context)
        self.chanin0 = RootSeqCxRbanaDpointfltrSgleChanin0(self._context)
        self.chanin3 = RootSeqCxRbanaDpointfltrSgleChanin3(self._context)
        self.fircoeffs = RootSeqCxRbanaDpointfltrSgleFircoeffs(self._context)
        self.chanin2 = RootSeqCxRbanaDpointfltrSgleChanin2(self._context)
        self.chanin14 = RootSeqCxRbanaDpointfltrSgleChanin14(self._context)
        self.chanin6 = RootSeqCxRbanaDpointfltrSgleChanin6(self._context)
        self.control = RootSeqCxRbanaDpointfltrSgleControl(self._context)
        self.chanin10 = RootSeqCxRbanaDpointfltrSgleChanin10(self._context)
        self.chanin13 = RootSeqCxRbanaDpointfltrSgleChanin13(self._context)
        self.chanin9 = RootSeqCxRbanaDpointfltrSgleChanin9(self._context)
        self.chanin8 = RootSeqCxRbanaDpointfltrSgleChanin8(self._context)
        self.chanin4 = RootSeqCxRbanaDpointfltrSgleChanin4(self._context)
        self.chanin12 = RootSeqCxRbanaDpointfltrSgleChanin12(self._context)
        self.status = RootSeqCxRbanaDpointfltrSgleStatus(self._context)


class RootSeqCxRbanaDpointfltr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.dpointfltr'
        self.sgle = RootSeqCxRbanaDpointfltrSgle(self._context)


class RootSeqCxRbanaDatacaptureSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.status'
        self.busy = RootSeqCxRbanaDatacaptureSgleStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleTimestampfirstmsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.timestampfirstmsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.timestampfirstmsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.timestampfirstmsb.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin6'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin6.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin6.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin6.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin6.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin6.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin6.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin4'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin4.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin4.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin4.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin4.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin4.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin5'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin5.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin5.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin5.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin5.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin5.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin5.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin7'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin7.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin7.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin7.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin7.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin7.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.selectin7.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires1'
        self.selectin7 = RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin7(self._context)
        self.selectin5 = RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin5(self._context)
        self.selectin4 = RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin4(self._context)
        self.selectin6 = RootSeqCxRbanaDatacaptureSgleSelecthires1Selectin6(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires1.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin2.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin1.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin0'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin0.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin0.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin0.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin0.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin0.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.selectin3.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleSelecthires0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.selecthires0'
        self.selectin3 = RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin3(self._context)
        self.selectin0 = RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin0(self._context)
        self.selectin1 = RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin1(self._context)
        self.selectin2 = RootSeqCxRbanaDatacaptureSgleSelecthires0Selectin2(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.selecthires0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.selecthires0.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleTimestampfirstlsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.timestampfirstlsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.timestampfirstlsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.timestampfirstlsb.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlEnablefastcapture(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.enablefastcapture'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.enablefastcapture.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.enablefastcapture.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.enablefastcapture.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.enablefastcapture.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.enablefastcapture.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.enablefastcapture.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlFastdivider(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.fastdivider'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.fastdivider.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.fastdivider.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.fastdivider.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.fastdivider.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.fastdivider.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.fastdivider.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlSelectfastin0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.selectfastin0'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.selectfastin0.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.selectfastin0.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.selectfastin0.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.selectfastin0.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.selectfastin0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.selectfastin0.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlSelectfastin1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.selectfastin1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.selectfastin1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.selectfastin1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.selectfastin1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.selectfastin1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.selectfastin1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.selectfastin1.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.start.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlEnablehirescapture(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.enablehirescapture'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.enablehirescapture.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.enablehirescapture.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.enablehirescapture.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.enablehirescapture.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.enablehirescapture.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.enablehirescapture.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlChanmaskfast(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.chanmaskfast'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.chanmaskfast.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.chanmaskfast.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.chanmaskfast.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.chanmaskfast.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.chanmaskfast.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.chanmaskfast.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControlChanmaskhires(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control.chanmaskhires'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.chanmaskhires.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.chanmaskhires.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.chanmaskhires.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.chanmaskhires.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.chanmaskhires.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.chanmaskhires.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle.control'
        self.chanmaskhires = RootSeqCxRbanaDatacaptureSgleControlChanmaskhires(self._context)
        self.chanmaskfast = RootSeqCxRbanaDatacaptureSgleControlChanmaskfast(self._context)
        self.enablehirescapture = RootSeqCxRbanaDatacaptureSgleControlEnablehirescapture(self._context)
        self.start = RootSeqCxRbanaDatacaptureSgleControlStart(self._context)
        self.abort = RootSeqCxRbanaDatacaptureSgleControlAbort(self._context)
        self.stop = RootSeqCxRbanaDatacaptureSgleControlStop(self._context)
        self.selectfastin1 = RootSeqCxRbanaDatacaptureSgleControlSelectfastin1(self._context)
        self.selectfastin0 = RootSeqCxRbanaDatacaptureSgleControlSelectfastin0(self._context)
        self.fastdivider = RootSeqCxRbanaDatacaptureSgleControlFastdivider(self._context)
        self.enablefastcapture = RootSeqCxRbanaDatacaptureSgleControlEnablefastcapture(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.datacapture.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.datacapture.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaDatacaptureSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture.sgle'
        self.control = RootSeqCxRbanaDatacaptureSgleControl(self._context)
        self.timestampfirstlsb = RootSeqCxRbanaDatacaptureSgleTimestampfirstlsb(self._context)
        self.selecthires0 = RootSeqCxRbanaDatacaptureSgleSelecthires0(self._context)
        self.selecthires1 = RootSeqCxRbanaDatacaptureSgleSelecthires1(self._context)
        self.timestampfirstmsb = RootSeqCxRbanaDatacaptureSgleTimestampfirstmsb(self._context)
        self.status = RootSeqCxRbanaDatacaptureSgleStatus(self._context)


class RootSeqCxRbanaDatacapture(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.datacapture'
        self.sgle = RootSeqCxRbanaDatacaptureSgle(self._context)


class RootSeqCxRbanaMemorysignalgenSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.busy.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleStatusFifolevel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.status.fifolevel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.fifolevel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.fifolevel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.fifolevel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.fifolevel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.fifolevel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.fifolevel.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleStatusUnderrun(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.status.underrun'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.underrun.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.underrun.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.underrun.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.underrun.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.underrun.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.underrun.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleStatusEndreached(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.status.endreached'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.endreached.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.endreached.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.endreached.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.endreached.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.endreached.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.endreached.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.status'
        self.endreached = RootSeqCxRbanaMemorysignalgenSgleStatusEndreached(self._context)
        self.underrun = RootSeqCxRbanaMemorysignalgenSgleStatusUnderrun(self._context)
        self.fifolevel = RootSeqCxRbanaMemorysignalgenSgleStatusFifolevel(self._context)
        self.busy = RootSeqCxRbanaMemorysignalgenSgleStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.status.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleSampleno(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.sampleno'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.sampleno.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.sampleno.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleSamplecnt(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.samplecnt'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.samplecnt.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.samplecnt.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleRvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.rvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.rvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.rvalue.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.increment.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleWvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.wvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.wvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.wvalue.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.out.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.stop.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlAddress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.address'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.address.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.address.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.address.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.address.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.address.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.address.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.abort.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlJoin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.join'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.join.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.join.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.join.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.join.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.join.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.join.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlOutaddress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.outaddress'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.outaddress.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.outaddress.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.outaddress.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.outaddress.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.outaddress.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.outaddress.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlLinear(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.linear'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.linear.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.linear.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.linear.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.linear.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.linear.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.linear.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlEnable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.enable.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlClear(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.clear'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.clear.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.clear.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.clear.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.clear.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.clear.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.clear.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.start.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle.control'
        self.start = RootSeqCxRbanaMemorysignalgenSgleControlStart(self._context)
        self.clear = RootSeqCxRbanaMemorysignalgenSgleControlClear(self._context)
        self.enable = RootSeqCxRbanaMemorysignalgenSgleControlEnable(self._context)
        self.linear = RootSeqCxRbanaMemorysignalgenSgleControlLinear(self._context)
        self.outaddress = RootSeqCxRbanaMemorysignalgenSgleControlOutaddress(self._context)
        self.join = RootSeqCxRbanaMemorysignalgenSgleControlJoin(self._context)
        self.abort = RootSeqCxRbanaMemorysignalgenSgleControlAbort(self._context)
        self.address = RootSeqCxRbanaMemorysignalgenSgleControlAddress(self._context)
        self.stop = RootSeqCxRbanaMemorysignalgenSgleControlStop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.memorysignalgen.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.memorysignalgen.sgle.control.regaddr', int(new_val))


class RootSeqCxRbanaMemorysignalgenSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen.sgle'
        self.control = RootSeqCxRbanaMemorysignalgenSgleControl(self._context)
        self.out = RootSeqCxRbanaMemorysignalgenSgleOut(self._context)
        self.wvalue = RootSeqCxRbanaMemorysignalgenSgleWvalue(self._context)
        self.increment = RootSeqCxRbanaMemorysignalgenSgleIncrement(self._context)
        self.rvalue = RootSeqCxRbanaMemorysignalgenSgleRvalue(self._context)
        self.samplecnt = RootSeqCxRbanaMemorysignalgenSgleSamplecnt(self._context)
        self.sampleno = RootSeqCxRbanaMemorysignalgenSgleSampleno(self._context)
        self.status = RootSeqCxRbanaMemorysignalgenSgleStatus(self._context)


class RootSeqCxRbanaMemorysignalgen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.memorysignalgen'
        self.sgle = RootSeqCxRbanaMemorysignalgenSgle(self._context)


class RootSeqCxRbanaComparatorComparator2Iircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.iircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.iircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.iircoef.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2Level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.level'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.level.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2Iiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.iiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.iiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.iiraddr.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2ControlComparatorinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.control.comparatorinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.comparatorinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.comparatorinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.comparatorinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.comparatorinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.comparatorinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.comparatorinput.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2ControlPolcomparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.control.polcomparator'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.polcomparator.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.polcomparator.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.polcomparator.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.polcomparator.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.polcomparator.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.polcomparator.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2ControlInputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.control.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.inputiir_vld.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2ControlFilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.control.filterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.filterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.filterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.filterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.filterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.filterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.filterena.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2.control'
        self.filterena = RootSeqCxRbanaComparatorComparator2ControlFilterena(self._context)
        self.inputiir_vld = RootSeqCxRbanaComparatorComparator2ControlInputiir_vld(self._context)
        self.polcomparator = RootSeqCxRbanaComparatorComparator2ControlPolcomparator(self._context)
        self.comparatorinput = RootSeqCxRbanaComparatorComparator2ControlComparatorinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator2.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator2.control.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator2'
        self.control = RootSeqCxRbanaComparatorComparator2Control(self._context)
        self.iiraddr = RootSeqCxRbanaComparatorComparator2Iiraddr(self._context)
        self.level = RootSeqCxRbanaComparatorComparator2Level(self._context)
        self.iircoef = RootSeqCxRbanaComparatorComparator2Iircoef(self._context)


class RootSeqCxRbanaComparatorComparator1Iircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.iircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.iircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.iircoef.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1Level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.level'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.level.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1Iiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.iiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.iiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.iiraddr.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1ControlComparatorinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.control.comparatorinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.comparatorinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.comparatorinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.comparatorinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.comparatorinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.comparatorinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.comparatorinput.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1ControlPolcomparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.control.polcomparator'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.polcomparator.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.polcomparator.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.polcomparator.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.polcomparator.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.polcomparator.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.polcomparator.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1ControlInputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.control.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.inputiir_vld.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1ControlFilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.control.filterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.filterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.filterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.filterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.filterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.filterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.filterena.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1.control'
        self.filterena = RootSeqCxRbanaComparatorComparator1ControlFilterena(self._context)
        self.inputiir_vld = RootSeqCxRbanaComparatorComparator1ControlInputiir_vld(self._context)
        self.polcomparator = RootSeqCxRbanaComparatorComparator1ControlPolcomparator(self._context)
        self.comparatorinput = RootSeqCxRbanaComparatorComparator1ControlComparatorinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator1.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator1.control.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator1'
        self.control = RootSeqCxRbanaComparatorComparator1Control(self._context)
        self.iiraddr = RootSeqCxRbanaComparatorComparator1Iiraddr(self._context)
        self.level = RootSeqCxRbanaComparatorComparator1Level(self._context)
        self.iircoef = RootSeqCxRbanaComparatorComparator1Iircoef(self._context)


class RootSeqCxRbanaComparatorComparator3Iircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.iircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.iircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.iircoef.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3Level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.level'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.level.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3Iiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.iiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.iiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.iiraddr.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3ControlComparatorinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.control.comparatorinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.comparatorinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.comparatorinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.comparatorinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.comparatorinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.comparatorinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.comparatorinput.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3ControlPolcomparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.control.polcomparator'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.polcomparator.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.polcomparator.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.polcomparator.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.polcomparator.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.polcomparator.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.polcomparator.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3ControlInputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.control.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.inputiir_vld.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3ControlFilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.control.filterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.filterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.filterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.filterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.filterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.filterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.filterena.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3.control'
        self.filterena = RootSeqCxRbanaComparatorComparator3ControlFilterena(self._context)
        self.inputiir_vld = RootSeqCxRbanaComparatorComparator3ControlInputiir_vld(self._context)
        self.polcomparator = RootSeqCxRbanaComparatorComparator3ControlPolcomparator(self._context)
        self.comparatorinput = RootSeqCxRbanaComparatorComparator3ControlComparatorinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.cx.rbana.comparator.comparator3.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.cx.rbana.comparator.comparator3.control.regaddr', int(new_val))


class RootSeqCxRbanaComparatorComparator3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator.comparator3'
        self.control = RootSeqCxRbanaComparatorComparator3Control(self._context)
        self.iiraddr = RootSeqCxRbanaComparatorComparator3Iiraddr(self._context)
        self.level = RootSeqCxRbanaComparatorComparator3Level(self._context)
        self.iircoef = RootSeqCxRbanaComparatorComparator3Iircoef(self._context)


class RootSeqCxRbanaComparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana.comparator'
        self.comparator3 = RootSeqCxRbanaComparatorComparator3(self._context)
        self.comparator1 = RootSeqCxRbanaComparatorComparator1(self._context)
        self.comparator2 = RootSeqCxRbanaComparatorComparator2(self._context)


class RootSeqCxRbana(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx.rbana'
        self.comparator = RootSeqCxRbanaComparator(self._context)
        self.memorysignalgen = RootSeqCxRbanaMemorysignalgen(self._context)
        self.datacapture = RootSeqCxRbanaDatacapture(self._context)
        self.dpointfltr = RootSeqCxRbanaDpointfltr(self._context)
        self.timer = RootSeqCxRbanaTimer(self._context)
        self.datasampler = RootSeqCxRbanaDatasampler(self._context)
        self.regaddr = RootSeqCxRbanaRegaddr(self._context)
        self.pid = RootSeqCxRbanaPid(self._context)
        self.zctrlex = RootSeqCxRbanaZctrlex(self._context)
        self.seq = RootSeqCxRbanaSeq(self._context)
        self.gpi = RootSeqCxRbanaGpi(self._context)
        self.analyzercommon = RootSeqCxRbanaAnalyzercommon(self._context)
        self.analyzer = RootSeqCxRbanaAnalyzer(self._context)
        self.outhirescommon = RootSeqCxRbanaOuthirescommon(self._context)
        self.rampgen = RootSeqCxRbanaRampgen(self._context)
        self.userio = RootSeqCxRbanaUserio(self._context)
        self.outfast = RootSeqCxRbanaOutfast(self._context)
        self.interna = RootSeqCxRbanaInterna(self._context)
        self.outhires = RootSeqCxRbanaOuthires(self._context)
        self.infast = RootSeqCxRbanaInfast(self._context)
        self.inhirescommon = RootSeqCxRbanaInhirescommon(self._context)
        self.outfastcommon = RootSeqCxRbanaOutfastcommon(self._context)
        self.ort = RootSeqCxRbanaOrt(self._context)
        self.inhires = RootSeqCxRbanaInhires(self._context)
        self.infastcommon = RootSeqCxRbanaInfastcommon(self._context)
        self.inchannelsdigi = RootSeqCxRbanaInchannelsdigi(self._context)
        self.eventmgr = RootSeqCxRbanaEventmgr(self._context)


class RootSeqCx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.cx'
        self.rbana = RootSeqCxRbana(self._context)


class RootSeqFlexRbanaEventmgrSgleStartmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.startmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.startmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.startmask.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleAborteventmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.aborteventmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.aborteventmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.aborteventmask.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleEventsnapshot(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.eventsnapshot'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.eventsnapshot.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.eventsnapshot.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleStatusAbortevent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.status.abortevent'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.abortevent.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.abortevent.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.abortevent.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.abortevent.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.abortevent.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.abortevent.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleStatusStopevent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.status.stopevent'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.stopevent.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.stopevent.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.stopevent.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.stopevent.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.stopevent.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.stopevent.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.status'
        self.stopevent = RootSeqFlexRbanaEventmgrSgleStatusStopevent(self._context)
        self.busy = RootSeqFlexRbanaEventmgrSgleStatusBusy(self._context)
        self.abortevent = RootSeqFlexRbanaEventmgrSgleStatusAbortevent(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.status.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleAndmask0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.andmask0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.andmask0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.andmask0.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleStopeventmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.stopeventmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.stopeventmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.stopeventmask.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleEventvector(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.eventvector'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.eventvector.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.eventvector.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControlSoftevent2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control.softevent2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent2.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControlSoftevent1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control.softevent1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent1.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControlSoftevent0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control.softevent0'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent0.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent0.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent0.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent0.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent0.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControlSoftevent3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control.softevent3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.softevent3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.softevent3.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.control'
        self.start = RootSeqFlexRbanaEventmgrSgleControlStart(self._context)
        self.softevent3 = RootSeqFlexRbanaEventmgrSgleControlSoftevent3(self._context)
        self.abort = RootSeqFlexRbanaEventmgrSgleControlAbort(self._context)
        self.stop = RootSeqFlexRbanaEventmgrSgleControlStop(self._context)
        self.softevent0 = RootSeqFlexRbanaEventmgrSgleControlSoftevent0(self._context)
        self.softevent1 = RootSeqFlexRbanaEventmgrSgleControlSoftevent1(self._context)
        self.softevent2 = RootSeqFlexRbanaEventmgrSgleControlSoftevent2(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgleStopmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle.stopmask'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.eventmgr.sgle.stopmask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.eventmgr.sgle.stopmask.regaddr', int(new_val))


class RootSeqFlexRbanaEventmgrSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr.sgle'
        self.stopmask = RootSeqFlexRbanaEventmgrSgleStopmask(self._context)
        self.control = RootSeqFlexRbanaEventmgrSgleControl(self._context)
        self.eventvector = RootSeqFlexRbanaEventmgrSgleEventvector(self._context)
        self.stopeventmask = RootSeqFlexRbanaEventmgrSgleStopeventmask(self._context)
        self.andmask0 = RootSeqFlexRbanaEventmgrSgleAndmask0(self._context)
        self.status = RootSeqFlexRbanaEventmgrSgleStatus(self._context)
        self.eventsnapshot = RootSeqFlexRbanaEventmgrSgleEventsnapshot(self._context)
        self.aborteventmask = RootSeqFlexRbanaEventmgrSgleAborteventmask(self._context)
        self.startmask = RootSeqFlexRbanaEventmgrSgleStartmask(self._context)


class RootSeqFlexRbanaEventmgr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.eventmgr'
        self.sgle = RootSeqFlexRbanaEventmgrSgle(self._context)


class RootSeqFlexRbanaInchannelsdigiSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inchannelsdigi.sgle.control'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inchannelsdigi.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inchannelsdigi.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaInchannelsdigiSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inchannelsdigi.sgle'
        self.control = RootSeqFlexRbanaInchannelsdigiSgleControl(self._context)


class RootSeqFlexRbanaInchannelsdigi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inchannelsdigi'
        self.sgle = RootSeqFlexRbanaInchannelsdigiSgle(self._context)


class RootSeqFlexRbanaInfastcommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infastcommon'


class RootSeqFlexRbanaInhiresCh8Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch8.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch8.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh8(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch8'
        self.gain = RootSeqFlexRbanaInhiresCh8Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh8Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh8Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh8Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh8Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh8Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh8Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh8Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh8Filterval(self._context)


class RootSeqFlexRbanaInhiresCh6Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch6.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch6.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch6'
        self.gain = RootSeqFlexRbanaInhiresCh6Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh6Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh6Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh6Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh6Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh6Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh6Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh6Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh6Filterval(self._context)


class RootSeqFlexRbanaInhiresCh7Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch7.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch7.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch7'
        self.gain = RootSeqFlexRbanaInhiresCh7Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh7Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh7Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh7Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh7Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh7Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh7Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh7Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh7Filterval(self._context)


class RootSeqFlexRbanaInhiresCh4Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch4.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch4.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch4'
        self.gain = RootSeqFlexRbanaInhiresCh4Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh4Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh4Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh4Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh4Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh4Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh4Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh4Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh4Filterval(self._context)


class RootSeqFlexRbanaInhiresCh3Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch3.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch3.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch3'
        self.gain = RootSeqFlexRbanaInhiresCh3Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh3Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh3Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh3Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh3Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh3Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh3Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh3Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh3Filterval(self._context)


class RootSeqFlexRbanaInhiresCh2Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch2.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch2'
        self.gain = RootSeqFlexRbanaInhiresCh2Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh2Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh2Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh2Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh2Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh2Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh2Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh2Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh2Filterval(self._context)


class RootSeqFlexRbanaInhiresCh1Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch1.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch1'
        self.gain = RootSeqFlexRbanaInhiresCh1Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh1Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh1Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh1Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh1Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh1Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh1Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh1Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh1Filterval(self._context)


class RootSeqFlexRbanaInhiresCh5Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Inputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.inputoffset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.inputoffset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.inputoffset.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Cccoefs0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.cccoefs0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.cccoefs0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.cccoefs0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhires.ch5.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhires.ch5.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInhiresCh5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires.ch5'
        self.gain = RootSeqFlexRbanaInhiresCh5Gain(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInhiresCh5Cccoefy0(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInhiresCh5Cccoefx0(self._context)
        self.cccoefs0 = RootSeqFlexRbanaInhiresCh5Cccoefs0(self._context)
        self.currentinval = RootSeqFlexRbanaInhiresCh5Currentinval(self._context)
        self.inputoffset = RootSeqFlexRbanaInhiresCh5Inputoffset(self._context)
        self.offset = RootSeqFlexRbanaInhiresCh5Offset(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInhiresCh5Cccoefz0(self._context)
        self.filterval = RootSeqFlexRbanaInhiresCh5Filterval(self._context)


class RootSeqFlexRbanaInhires(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhires'
        self.ch5 = RootSeqFlexRbanaInhiresCh5(self._context)
        self.ch1 = RootSeqFlexRbanaInhiresCh1(self._context)
        self.ch2 = RootSeqFlexRbanaInhiresCh2(self._context)
        self.ch3 = RootSeqFlexRbanaInhiresCh3(self._context)
        self.ch4 = RootSeqFlexRbanaInhiresCh4(self._context)
        self.ch7 = RootSeqFlexRbanaInhiresCh7(self._context)
        self.ch6 = RootSeqFlexRbanaInhiresCh6(self._context)
        self.ch8 = RootSeqFlexRbanaInhiresCh8(self._context)


class RootSeqFlexRbanaOutfastcommonSgleDampinggain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.dampinggain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.dampinggain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.dampinggain.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlAdddamping1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.adddamping1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping1.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalhiresmodulation2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation2.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalhiresmodulation1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalhiresmodulation1.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalmodulation2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation2.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlAdddamping2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.adddamping2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddamping2.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlSelectout2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.selectout2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.selectout2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.selectout2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.selectout2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.selectout2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.selectout2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.selectout2.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlSelectout1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.selectout1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.selectout1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.selectout1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.selectout1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.selectout1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.selectout1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.selectout1.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalmodulation1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.adddigitalmodulation1.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle.control'
        self.adddigitalmodulation1 = RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalmodulation1(self._context)
        self.selectout1 = RootSeqFlexRbanaOutfastcommonSgleControlSelectout1(self._context)
        self.selectout2 = RootSeqFlexRbanaOutfastcommonSgleControlSelectout2(self._context)
        self.adddamping2 = RootSeqFlexRbanaOutfastcommonSgleControlAdddamping2(self._context)
        self.adddigitalmodulation2 = RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalmodulation2(self._context)
        self.adddigitalhiresmodulation1 = RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalhiresmodulation1(self._context)
        self.adddigitalhiresmodulation2 = RootSeqFlexRbanaOutfastcommonSgleControlAdddigitalhiresmodulation2(self._context)
        self.adddamping1 = RootSeqFlexRbanaOutfastcommonSgleControlAdddamping1(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfastcommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfastcommon.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastcommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon.sgle'
        self.control = RootSeqFlexRbanaOutfastcommonSgleControl(self._context)
        self.dampinggain = RootSeqFlexRbanaOutfastcommonSgleDampinggain(self._context)


class RootSeqFlexRbanaOutfastcommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfastcommon'
        self.sgle = RootSeqFlexRbanaOutfastcommonSgle(self._context)


class RootSeqFlexRbanaOuthiresCh8Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh8ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh8ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh8ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch8.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch8.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh8(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch8'
        self.control = RootSeqFlexRbanaOuthiresCh8Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh8Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh8Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh8Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh8Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh8Gain(self._context)


class RootSeqFlexRbanaOuthiresCh6Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh6ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh6ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh6ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch6.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch6.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch6'
        self.control = RootSeqFlexRbanaOuthiresCh6Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh6Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh6Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh6Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh6Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh6Gain(self._context)


class RootSeqFlexRbanaOuthiresCh7Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh7ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh7ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh7ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch7.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch7.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch7'
        self.control = RootSeqFlexRbanaOuthiresCh7Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh7Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh7Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh7Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh7Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh7Gain(self._context)


class RootSeqFlexRbanaOuthiresCh4Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh4ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh4ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh4ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch4.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch4.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch4'
        self.control = RootSeqFlexRbanaOuthiresCh4Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh4Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh4Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh4Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh4Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh4Gain(self._context)


class RootSeqFlexRbanaOuthiresCh3Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh3ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh3ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh3ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch3.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch3.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch3'
        self.control = RootSeqFlexRbanaOuthiresCh3Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh3Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh3Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh3Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh3Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh3Gain(self._context)


class RootSeqFlexRbanaOuthiresCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh2ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh2ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh2ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch2.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch2.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch2'
        self.control = RootSeqFlexRbanaOuthiresCh2Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh2Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh2Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh2Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh2Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh2Gain(self._context)


class RootSeqFlexRbanaOuthiresCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh1ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh1ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh1ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch1.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch1.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch1'
        self.control = RootSeqFlexRbanaOuthiresCh1Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh1Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh1Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh1Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh1Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh1Gain(self._context)


class RootSeqFlexRbanaOuthiresCh5Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5Filterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.filterval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.filterval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.filterval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5ControlAdddigitalmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.control.adddigitalmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.adddigitalmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.adddigitalmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.adddigitalmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.adddigitalmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.adddigitalmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.adddigitalmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5ControlBypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.control.bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5ControlSelectout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.control.selectout'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.selectout.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.selectout.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.selectout.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.selectout.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.selectout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.selectout.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5.control'
        self.selectout = RootSeqFlexRbanaOuthiresCh5ControlSelectout(self._context)
        self.bypassfilter = RootSeqFlexRbanaOuthiresCh5ControlBypassfilter(self._context)
        self.adddigitalmodulation = RootSeqFlexRbanaOuthiresCh5ControlAdddigitalmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhires.ch5.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhires.ch5.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthiresCh5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires.ch5'
        self.control = RootSeqFlexRbanaOuthiresCh5Control(self._context)
        self.testvalue = RootSeqFlexRbanaOuthiresCh5Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOuthiresCh5Currentoutval(self._context)
        self.offset = RootSeqFlexRbanaOuthiresCh5Offset(self._context)
        self.filterval = RootSeqFlexRbanaOuthiresCh5Filterval(self._context)
        self.gain = RootSeqFlexRbanaOuthiresCh5Gain(self._context)


class RootSeqFlexRbanaOuthires(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhires'
        self.ch5 = RootSeqFlexRbanaOuthiresCh5(self._context)
        self.ch1 = RootSeqFlexRbanaOuthiresCh1(self._context)
        self.ch2 = RootSeqFlexRbanaOuthiresCh2(self._context)
        self.ch3 = RootSeqFlexRbanaOuthiresCh3(self._context)
        self.ch4 = RootSeqFlexRbanaOuthiresCh4(self._context)
        self.ch7 = RootSeqFlexRbanaOuthiresCh7(self._context)
        self.ch6 = RootSeqFlexRbanaOuthiresCh6(self._context)
        self.ch8 = RootSeqFlexRbanaOuthiresCh8(self._context)


class RootSeqFlexRbanaInhirescommonSgleControlCh3bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch3bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch3bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch3bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch3bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch3bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch3bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch3bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControlCh1bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch1bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch1bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch1bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch1bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch1bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch1bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch1bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControlCh5bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch5bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch5bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch5bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch5bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch5bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch5bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch5bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControlCh7bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch7bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch7bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch7bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch7bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch7bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch7bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch7bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControlCh4bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch4bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch4bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch4bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch4bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch4bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch4bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch4bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControlCh2bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch2bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch2bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch2bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch2bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch2bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch2bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch2bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControlCh6bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch6bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch6bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch6bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch6bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch6bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch6bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch6bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControlCh8bypassfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control.ch8bypassfilter'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch8bypassfilter.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch8bypassfilter.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch8bypassfilter.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch8bypassfilter.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.ch8bypassfilter.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.ch8bypassfilter.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.control'
        self.ch8bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh8bypassfilter(self._context)
        self.ch6bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh6bypassfilter(self._context)
        self.ch2bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh2bypassfilter(self._context)
        self.ch4bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh4bypassfilter(self._context)
        self.ch7bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh7bypassfilter(self._context)
        self.ch5bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh5bypassfilter(self._context)
        self.ch1bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh1bypassfilter(self._context)
        self.ch3bypassfilter = RootSeqFlexRbanaInhirescommonSgleControlCh3bypassfilter(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleAafcoefAddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.aafcoef.addr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.addr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.addr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.addr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.addr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.addr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.addr.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleAafcoefData(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.aafcoef.data'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.data.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.data.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.data.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.data.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.data.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.data.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgleAafcoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle.aafcoef'
        self.data = RootSeqFlexRbanaInhirescommonSgleAafcoefData(self._context)
        self.addr = RootSeqFlexRbanaInhirescommonSgleAafcoefAddr(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.inhirescommon.sgle.aafcoef.regaddr', int(new_val))


class RootSeqFlexRbanaInhirescommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon.sgle'
        self.aafcoef = RootSeqFlexRbanaInhirescommonSgleAafcoef(self._context)
        self.control = RootSeqFlexRbanaInhirescommonSgleControl(self._context)


class RootSeqFlexRbanaInhirescommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.inhirescommon'
        self.sgle = RootSeqFlexRbanaInhirescommonSgle(self._context)


class RootSeqFlexRbanaInfastCh1Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch1.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch1.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch1.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh1Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch1.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch1.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch1.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch1.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh1Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch1.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch1.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch1.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh1Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch1.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch1.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch1.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch1.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch1'
        self.gain = RootSeqFlexRbanaInfastCh1Gain(self._context)
        self.currentinval = RootSeqFlexRbanaInfastCh1Currentinval(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInfastCh1Cccoefy0(self._context)
        self.offset = RootSeqFlexRbanaInfastCh1Offset(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInfastCh1Cccoefx0(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInfastCh1Cccoefz0(self._context)


class RootSeqFlexRbanaInfastCh2Cccoefz0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch2.cccoefz0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch2.cccoefz0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch2.cccoefz0.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh2Cccoefx0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch2.cccoefx0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch2.cccoefx0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch2.cccoefx0.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch2.offset.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh2Cccoefy0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch2.cccoefy0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch2.cccoefy0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch2.cccoefy0.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh2Currentinval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch2.currentinval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch2.currentinval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch2.currentinval.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.infast.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.infast.ch2.gain.regaddr', int(new_val))


class RootSeqFlexRbanaInfastCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast.ch2'
        self.gain = RootSeqFlexRbanaInfastCh2Gain(self._context)
        self.currentinval = RootSeqFlexRbanaInfastCh2Currentinval(self._context)
        self.cccoefy0 = RootSeqFlexRbanaInfastCh2Cccoefy0(self._context)
        self.offset = RootSeqFlexRbanaInfastCh2Offset(self._context)
        self.cccoefx0 = RootSeqFlexRbanaInfastCh2Cccoefx0(self._context)
        self.cccoefz0 = RootSeqFlexRbanaInfastCh2Cccoefz0(self._context)


class RootSeqFlexRbanaInfast(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.infast'
        self.ch2 = RootSeqFlexRbanaInfastCh2(self._context)
        self.ch1 = RootSeqFlexRbanaInfastCh1(self._context)


class RootSeqFlexRbanaOuthirescommonSgleGpfiltrcoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhirescommon.sgle.gpfiltrcoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.gpfiltrcoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.gpfiltrcoef.regaddr', int(new_val))


class RootSeqFlexRbanaOuthirescommonSgleGpfiltraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhirescommon.sgle.gpfiltraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.gpfiltraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.gpfiltraddr.regaddr', int(new_val))


class RootSeqFlexRbanaOuthirescommonSgleControlGpflt_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhirescommon.sgle.control.gpflt_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.control.gpflt_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.control.gpflt_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.control.gpflt_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.control.gpflt_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.control.gpflt_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.control.gpflt_vld.regaddr', int(new_val))


class RootSeqFlexRbanaOuthirescommonSgleControlSelectmod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhirescommon.sgle.control.selectmod'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.control.selectmod.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.control.selectmod.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.control.selectmod.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.control.selectmod.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.control.selectmod.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.control.selectmod.regaddr', int(new_val))


class RootSeqFlexRbanaOuthirescommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhirescommon.sgle.control'
        self.selectmod = RootSeqFlexRbanaOuthirescommonSgleControlSelectmod(self._context)
        self.gpflt_vld = RootSeqFlexRbanaOuthirescommonSgleControlGpflt_vld(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outhirescommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outhirescommon.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaOuthirescommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhirescommon.sgle'
        self.control = RootSeqFlexRbanaOuthirescommonSgleControl(self._context)
        self.gpfiltraddr = RootSeqFlexRbanaOuthirescommonSgleGpfiltraddr(self._context)
        self.gpfiltrcoef = RootSeqFlexRbanaOuthirescommonSgleGpfiltrcoef(self._context)


class RootSeqFlexRbanaOuthirescommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outhirescommon'
        self.sgle = RootSeqFlexRbanaOuthirescommonSgle(self._context)


class RootSeqFlexRbanaInternaSgleControlRst8chconverters(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.interna.sgle.control.rst8chconverters'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.interna.sgle.control.rst8chconverters.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.interna.sgle.control.rst8chconverters.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.interna.sgle.control.rst8chconverters.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.interna.sgle.control.rst8chconverters.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.interna.sgle.control.rst8chconverters.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.interna.sgle.control.rst8chconverters.regaddr', int(new_val))


class RootSeqFlexRbanaInternaSgleControlStatusled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.interna.sgle.control.statusled'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.interna.sgle.control.statusled.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.interna.sgle.control.statusled.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.interna.sgle.control.statusled.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.interna.sgle.control.statusled.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.interna.sgle.control.statusled.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.interna.sgle.control.statusled.regaddr', int(new_val))


class RootSeqFlexRbanaInternaSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.interna.sgle.control'
        self.statusled = RootSeqFlexRbanaInternaSgleControlStatusled(self._context)
        self.rst8chconverters = RootSeqFlexRbanaInternaSgleControlRst8chconverters(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.interna.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.interna.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaInternaSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.interna.sgle'
        self.control = RootSeqFlexRbanaInternaSgleControl(self._context)


class RootSeqFlexRbanaInterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.interna'
        self.sgle = RootSeqFlexRbanaInternaSgle(self._context)


class RootSeqFlexRbanaOutfastCh1Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch1.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch1.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch1.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh1Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch1.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch1.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch1.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh1Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch1.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch1.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch1.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh1Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch1.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch1.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch1.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch1'
        self.gain = RootSeqFlexRbanaOutfastCh1Gain(self._context)
        self.offset = RootSeqFlexRbanaOutfastCh1Offset(self._context)
        self.testvalue = RootSeqFlexRbanaOutfastCh1Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOutfastCh1Currentoutval(self._context)


class RootSeqFlexRbanaOutfastCh2Currentoutval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch2.currentoutval'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch2.currentoutval.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch2.currentoutval.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh2Testvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch2.testvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch2.testvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch2.testvalue.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh2Offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch2.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch2.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch2.offset.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh2Gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch2.gain'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.outfast.ch2.gain.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.outfast.ch2.gain.regaddr', int(new_val))


class RootSeqFlexRbanaOutfastCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast.ch2'
        self.gain = RootSeqFlexRbanaOutfastCh2Gain(self._context)
        self.offset = RootSeqFlexRbanaOutfastCh2Offset(self._context)
        self.testvalue = RootSeqFlexRbanaOutfastCh2Testvalue(self._context)
        self.currentoutval = RootSeqFlexRbanaOutfastCh2Currentoutval(self._context)


class RootSeqFlexRbanaOutfast(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.outfast'
        self.ch2 = RootSeqFlexRbanaOutfastCh2(self._context)
        self.ch1 = RootSeqFlexRbanaOutfastCh1(self._context)


class RootSeqFlexRbanaUserioSgleDigitalin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.digitalin'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.digitalin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.digitalin.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut1src(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out1src'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1src.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1src.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1src.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1src.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1src.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1src.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut2level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out2level'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2level.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2level.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2level.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2level.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2level.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut1level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out1level'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1level.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1level.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1level.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1level.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1level.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut2type(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out2type'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2type.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2type.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2type.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2type.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2type.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2type.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlIn2enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.in2enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.in2enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.in2enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.in2enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.in2enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.in2enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.in2enable.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut2src(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out2src'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2src.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2src.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2src.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2src.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2src.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2src.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut1type(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out1type'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1type.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1type.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1type.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1type.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1type.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1type.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut2enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out2enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out2enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out2enable.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlOut1enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.out1enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.out1enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.out1enable.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControlIn1enable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control.in1enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.in1enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.in1enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.in1enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.in1enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.in1enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.in1enable.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle.control'
        self.in1enable = RootSeqFlexRbanaUserioSgleControlIn1enable(self._context)
        self.out1enable = RootSeqFlexRbanaUserioSgleControlOut1enable(self._context)
        self.out2enable = RootSeqFlexRbanaUserioSgleControlOut2enable(self._context)
        self.out1type = RootSeqFlexRbanaUserioSgleControlOut1type(self._context)
        self.out2src = RootSeqFlexRbanaUserioSgleControlOut2src(self._context)
        self.in2enable = RootSeqFlexRbanaUserioSgleControlIn2enable(self._context)
        self.out2type = RootSeqFlexRbanaUserioSgleControlOut2type(self._context)
        self.out1level = RootSeqFlexRbanaUserioSgleControlOut1level(self._context)
        self.out2level = RootSeqFlexRbanaUserioSgleControlOut2level(self._context)
        self.out1src = RootSeqFlexRbanaUserioSgleControlOut1src(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.userio.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.userio.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaUserioSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio.sgle'
        self.control = RootSeqFlexRbanaUserioSgleControl(self._context)
        self.digitalin = RootSeqFlexRbanaUserioSgleDigitalin(self._context)


class RootSeqFlexRbanaUserio(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.userio'
        self.sgle = RootSeqFlexRbanaUserioSgle(self._context)


class RootSeqFlexRbanaRampgenTipvoltageStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.status'
        self.countup = RootSeqFlexRbanaRampgenTipvoltageStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenTipvoltageStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenTipvoltageStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenTipvoltageStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenTipvoltageStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltageControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage.control'
        self.start = RootSeqFlexRbanaRampgenTipvoltageControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenTipvoltageControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenTipvoltageControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenTipvoltageControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenTipvoltageControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.tipvoltage.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.tipvoltage.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTipvoltage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.tipvoltage'
        self.control = RootSeqFlexRbanaRampgenTipvoltageControl(self._context)
        self.out = RootSeqFlexRbanaRampgenTipvoltageOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenTipvoltageLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenTipvoltageLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenTipvoltageValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenTipvoltageIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenTipvoltageStatus(self._context)


class RootSeqFlexRbanaRampgenUser4StatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4StatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4StatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4StatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4StatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.status'
        self.countup = RootSeqFlexRbanaRampgenUser4StatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenUser4StatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenUser4StatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenUser4StatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenUser4StatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4Increment(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4Value(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4Limit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4Limit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4Out(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4ControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4ControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4ControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4ControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4.control'
        self.start = RootSeqFlexRbanaRampgenUser4ControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenUser4ControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenUser4ControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenUser4ControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenUser4ControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.user4.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.user4.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.user4'
        self.control = RootSeqFlexRbanaRampgenUser4Control(self._context)
        self.out = RootSeqFlexRbanaRampgenUser4Out(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenUser4Limit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenUser4Limit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenUser4Value(self._context)
        self.increment = RootSeqFlexRbanaRampgenUser4Increment(self._context)
        self.status = RootSeqFlexRbanaRampgenUser4Status(self._context)


class RootSeqFlexRbanaRampgenPlanezStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.status'
        self.countup = RootSeqFlexRbanaRampgenPlanezStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenPlanezStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenPlanezStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenPlanezStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenPlanezStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanezControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez.control'
        self.start = RootSeqFlexRbanaRampgenPlanezControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenPlanezControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenPlanezControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenPlanezControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenPlanezControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.planez.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.planez.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPlanez(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.planez'
        self.control = RootSeqFlexRbanaRampgenPlanezControl(self._context)
        self.out = RootSeqFlexRbanaRampgenPlanezOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenPlanezLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenPlanezLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenPlanezValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenPlanezIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenPlanezStatus(self._context)


class RootSeqFlexRbanaRampgenPositionxStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.status'
        self.countup = RootSeqFlexRbanaRampgenPositionxStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenPositionxStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenPositionxStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenPositionxStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenPositionxStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionxControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx.control'
        self.start = RootSeqFlexRbanaRampgenPositionxControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenPositionxControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenPositionxControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenPositionxControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenPositionxControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positionx.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positionx.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positionx'
        self.control = RootSeqFlexRbanaRampgenPositionxControl(self._context)
        self.out = RootSeqFlexRbanaRampgenPositionxOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenPositionxLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenPositionxLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenPositionxValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenPositionxIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenPositionxStatus(self._context)


class RootSeqFlexRbanaRampgenTestStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.status'
        self.countup = RootSeqFlexRbanaRampgenTestStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenTestStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenTestStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenTestStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenTestStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTestControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test.control'
        self.start = RootSeqFlexRbanaRampgenTestControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenTestControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenTestControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenTestControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenTestControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.test.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.test.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenTest(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.test'
        self.control = RootSeqFlexRbanaRampgenTestControl(self._context)
        self.out = RootSeqFlexRbanaRampgenTestOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenTestLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenTestLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenTestValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenTestIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenTestStatus(self._context)


class RootSeqFlexRbanaRampgenApproachStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.status'
        self.countup = RootSeqFlexRbanaRampgenApproachStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenApproachStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenApproachStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenApproachStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenApproachStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproachControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach.control'
        self.start = RootSeqFlexRbanaRampgenApproachControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenApproachControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenApproachControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenApproachControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenApproachControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.approach.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.approach.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.approach'
        self.control = RootSeqFlexRbanaRampgenApproachControl(self._context)
        self.out = RootSeqFlexRbanaRampgenApproachOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenApproachLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenApproachLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenApproachValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenApproachIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenApproachStatus(self._context)


class RootSeqFlexRbanaRampgenAlternatezStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.status'
        self.countup = RootSeqFlexRbanaRampgenAlternatezStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenAlternatezStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenAlternatezStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenAlternatezStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenAlternatezStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatezControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez.control'
        self.start = RootSeqFlexRbanaRampgenAlternatezControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenAlternatezControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenAlternatezControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenAlternatezControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenAlternatezControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.alternatez.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.alternatez.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenAlternatez(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.alternatez'
        self.control = RootSeqFlexRbanaRampgenAlternatezControl(self._context)
        self.out = RootSeqFlexRbanaRampgenAlternatezOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenAlternatezLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenAlternatezLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenAlternatezValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenAlternatezIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenAlternatezStatus(self._context)


class RootSeqFlexRbanaRampgenPositionyStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.status'
        self.countup = RootSeqFlexRbanaRampgenPositionyStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenPositionyStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenPositionyStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenPositionyStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenPositionyStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositionyControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony.control'
        self.start = RootSeqFlexRbanaRampgenPositionyControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenPositionyControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenPositionyControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenPositionyControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenPositionyControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.positiony.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.positiony.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenPositiony(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.positiony'
        self.control = RootSeqFlexRbanaRampgenPositionyControl(self._context)
        self.out = RootSeqFlexRbanaRampgenPositionyOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenPositionyLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenPositionyLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenPositionyValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenPositionyIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenPositionyStatus(self._context)


class RootSeqFlexRbanaRampgenMaxzStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzStatusReachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.status.reachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzStatusReachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.status.reachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzStatusReachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.status.reachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.reachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.reachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzStatusCountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.status.countup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.countup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.countup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.countup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.countup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.countup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.countup.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.status'
        self.countup = RootSeqFlexRbanaRampgenMaxzStatusCountup(self._context)
        self.reachedupperlimit = RootSeqFlexRbanaRampgenMaxzStatusReachedupperlimit(self._context)
        self.reachedlowerlimit = RootSeqFlexRbanaRampgenMaxzStatusReachedlowerlimit(self._context)
        self.reachedregularend = RootSeqFlexRbanaRampgenMaxzStatusReachedregularend(self._context)
        self.busy = RootSeqFlexRbanaRampgenMaxzStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.status.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.increment.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzValue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.value.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzLimit_neg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.limit_neg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.limit_neg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.limit_neg.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzLimit_pos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.limit_pos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.limit_pos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.limit_pos.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.out.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzControlInit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.control.init'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.init.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.init.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.init.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.init.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.init.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.init.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxzControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz.control'
        self.start = RootSeqFlexRbanaRampgenMaxzControlStart(self._context)
        self.abort = RootSeqFlexRbanaRampgenMaxzControlAbort(self._context)
        self.init = RootSeqFlexRbanaRampgenMaxzControlInit(self._context)
        self.stop = RootSeqFlexRbanaRampgenMaxzControlStop(self._context)
        self.mode = RootSeqFlexRbanaRampgenMaxzControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.rampgen.maxz.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.rampgen.maxz.control.regaddr', int(new_val))


class RootSeqFlexRbanaRampgenMaxz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen.maxz'
        self.control = RootSeqFlexRbanaRampgenMaxzControl(self._context)
        self.out = RootSeqFlexRbanaRampgenMaxzOut(self._context)
        self.limit_pos = RootSeqFlexRbanaRampgenMaxzLimit_pos(self._context)
        self.limit_neg = RootSeqFlexRbanaRampgenMaxzLimit_neg(self._context)
        self.value = RootSeqFlexRbanaRampgenMaxzValue(self._context)
        self.increment = RootSeqFlexRbanaRampgenMaxzIncrement(self._context)
        self.status = RootSeqFlexRbanaRampgenMaxzStatus(self._context)


class RootSeqFlexRbanaRampgen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.rampgen'
        self.maxz = RootSeqFlexRbanaRampgenMaxz(self._context)
        self.positiony = RootSeqFlexRbanaRampgenPositiony(self._context)
        self.alternatez = RootSeqFlexRbanaRampgenAlternatez(self._context)
        self.approach = RootSeqFlexRbanaRampgenApproach(self._context)
        self.test = RootSeqFlexRbanaRampgenTest(self._context)
        self.positionx = RootSeqFlexRbanaRampgenPositionx(self._context)
        self.planez = RootSeqFlexRbanaRampgenPlanez(self._context)
        self.user4 = RootSeqFlexRbanaRampgenUser4(self._context)
        self.tipvoltage = RootSeqFlexRbanaRampgenTipvoltage(self._context)


class RootSeqFlexRbanaZctrlexSgleCurrentrampvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.currentrampvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.currentrampvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.currentrampvalue.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleCurrentphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.currentphase'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.currentphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.currentphase.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleInputiirout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.inputiirout'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.inputiirout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.inputiirout.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP3movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p3movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p3movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p3movevalue.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP2moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p2moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p2moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p2moveinc.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleClp_pid_gain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_p.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleClp_pid_gain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_d.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleFb_pid_gain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_d.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleError(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.error'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.error.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.error.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP0moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p0moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p0moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p0moveinc.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSglePhase0realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.phase0realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.phase0realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.phase0realendpos.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSglePhase2realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.phase2realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.phase2realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.phase2realendpos.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSglePhase3realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.phase3realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.phase3realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.phase3realendpos.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleOutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.output'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.output.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.output.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleTotphasenbr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.totphasenbr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.totphasenbr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.totphasenbr.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleMinzvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.minzvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.minzvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.minzvalue.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSglePhase1realendpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.phase1realendpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.phase1realendpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.phase1realendpos.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleZoutlimited(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.zoutlimited'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.zoutlimited.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.zoutlimited.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP2movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p2movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p2movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p2movevalue.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleFb_pid_gain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_p.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP0movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p0movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p0movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p0movevalue.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleRampgenctrlzout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzout'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzout.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzout.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P3workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p3workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3workmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P2movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2movestopbyvalueactive.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P3movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3movestopbyvalueactive.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P0movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0movestopbyvalueactive.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P0workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p0workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0workmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P2workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p2workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2workmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P1workmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p1workmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1workmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1workmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1workmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1workmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1workmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1workmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P3moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p3moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p3moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p3moveendmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P1movestopbyvalueactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1movestopbyvalueactive.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P0moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p0moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p0moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p0moveendmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P1moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p1moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p1moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p1moveendmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1P2moveendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1.p2moveendmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2moveendmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2moveendmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2moveendmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2moveendmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.p2moveendmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.p2moveendmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control1'
        self.p2moveendmode = RootSeqFlexRbanaZctrlexSgleControl1P2moveendmode(self._context)
        self.p1moveendmode = RootSeqFlexRbanaZctrlexSgleControl1P1moveendmode(self._context)
        self.p0moveendmode = RootSeqFlexRbanaZctrlexSgleControl1P0moveendmode(self._context)
        self.p1movestopbyvalueactive = RootSeqFlexRbanaZctrlexSgleControl1P1movestopbyvalueactive(self._context)
        self.p3moveendmode = RootSeqFlexRbanaZctrlexSgleControl1P3moveendmode(self._context)
        self.p1workmode = RootSeqFlexRbanaZctrlexSgleControl1P1workmode(self._context)
        self.p2workmode = RootSeqFlexRbanaZctrlexSgleControl1P2workmode(self._context)
        self.p0workmode = RootSeqFlexRbanaZctrlexSgleControl1P0workmode(self._context)
        self.p0movestopbyvalueactive = RootSeqFlexRbanaZctrlexSgleControl1P0movestopbyvalueactive(self._context)
        self.p3movestopbyvalueactive = RootSeqFlexRbanaZctrlexSgleControl1P3movestopbyvalueactive(self._context)
        self.p2movestopbyvalueactive = RootSeqFlexRbanaZctrlexSgleControl1P2movestopbyvalueactive(self._context)
        self.p3workmode = RootSeqFlexRbanaZctrlexSgleControl1P3workmode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control1.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.errorlimit.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSglePidcommand(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.pidcommand'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.pidcommand.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.pidcommand.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleRampgenctrlzlimitpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzlimitpos'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzlimitpos.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzlimitpos.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzreachedlowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedlowerlimit.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusZctrlexrampgenmaxzdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenmaxzdone.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusZctrlexactivaterunmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.zctrlexactivaterunmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexactivaterunmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusZctrlexreachedminz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedminz'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedminz.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedminz.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedminz.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedminz.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedminz.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedminz.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzbusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzbusy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzbusy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzbusy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzbusy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzbusy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzbusy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzbusy.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusZctrlexrampgenctrlzdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexrampgenctrlzdone.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzreachedupperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedupperlimit.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzcountup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzcountup'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzcountup.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzcountup.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzcountup.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzcountup.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzcountup.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzcountup.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusZctrlexinternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.zctrlexinternaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexinternaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexinternaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexinternaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexinternaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexinternaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexinternaloaded.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzreachedregularend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.rampgenctrlzreachedregularend.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusZctrlexreachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachederrlim.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusZctrlexreachedmaxz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedmaxz'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.zctrlexreachedmaxz.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusStopwhileprocessing(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.stopwhileprocessing'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.stopwhileprocessing.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.stopwhileprocessing.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.stopwhileprocessing.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.stopwhileprocessing.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.stopwhileprocessing.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.stopwhileprocessing.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatusEndofphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status.endofphase'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.endofphase.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.endofphase.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.endofphase.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.endofphase.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.endofphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.endofphase.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.status'
        self.endofphase = RootSeqFlexRbanaZctrlexSgleStatusEndofphase(self._context)
        self.stopwhileprocessing = RootSeqFlexRbanaZctrlexSgleStatusStopwhileprocessing(self._context)
        self.zctrlexreachedmaxz = RootSeqFlexRbanaZctrlexSgleStatusZctrlexreachedmaxz(self._context)
        self.zctrlexreachederrlim = RootSeqFlexRbanaZctrlexSgleStatusZctrlexreachederrlim(self._context)
        self.rampgenctrlzreachedregularend = RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzreachedregularend(self._context)
        self.zctrlexinternaloaded = RootSeqFlexRbanaZctrlexSgleStatusZctrlexinternaloaded(self._context)
        self.rampgenctrlzcountup = RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzcountup(self._context)
        self.rampgenctrlzreachedupperlimit = RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzreachedupperlimit(self._context)
        self.zctrlexrampgenctrlzdone = RootSeqFlexRbanaZctrlexSgleStatusZctrlexrampgenctrlzdone(self._context)
        self.rampgenctrlzbusy = RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzbusy(self._context)
        self.zctrlexreachedminz = RootSeqFlexRbanaZctrlexSgleStatusZctrlexreachedminz(self._context)
        self.zctrlexactivaterunmode = RootSeqFlexRbanaZctrlexSgleStatusZctrlexactivaterunmode(self._context)
        self.zctrlexrampgenmaxzdone = RootSeqFlexRbanaZctrlexSgleStatusZctrlexrampgenmaxzdone(self._context)
        self.rampgenctrlzreachedlowerlimit = RootSeqFlexRbanaZctrlexSgleStatusRampgenctrlzreachedlowerlimit(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.status.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP1moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p1moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p1moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p1moveinc.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleSum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.sum'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.sum.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.sum.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP3moveinc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p3moveinc'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p3moveinc.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p3moveinc.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleInputiiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.inputiiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.inputiiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.inputiiraddr.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleCompdcwithz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.compdcwithz'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.compdcwithz.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.compdcwithz.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleFb_pid_gain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.fb_pid_gain_i.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.input'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.input.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.input.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleP1movevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.p1movevalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.p1movevalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.p1movevalue.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleInputiircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.inputiircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.inputiircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.inputiircoef.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleRampgenctrlzlimitneg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzlimitneg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzlimitneg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.rampgenctrlzlimitneg.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleSetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.setpoint'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.setpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.setpoint.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleClp_pid_gain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.clp_pid_gain_i.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Setpointmodulationena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.setpointmodulationena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.setpointmodulationena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.setpointmodulationena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.setpointmodulationena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.setpointmodulationena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.setpointmodulationena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.setpointmodulationena.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Memorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.memorygenpositionena.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Inputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.inputiir_vld.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Zctrlexpolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolcomperrlim.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Outputmodulationena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.outputmodulationena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.outputmodulationena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.outputmodulationena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.outputmodulationena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.outputmodulationena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.outputmodulationena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.outputmodulationena.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Abort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.abort.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Stop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.stop.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Zctrlexpolpidinfb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinfb.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Zctrlexmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexmode.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Zctrlexinputchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexinputchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexinputchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexinputchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexinputchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexinputchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexinputchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexinputchan.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Memorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.memorygendriveena.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Zctrlexpolpidinzclp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexpolpidinzclp.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Zctrlexloadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexloadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexloadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexloadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexloadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexloadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexloadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.zctrlexloadinterna.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0Start(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.start.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgleControl0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle.control0'
        self.start = RootSeqFlexRbanaZctrlexSgleControl0Start(self._context)
        self.zctrlexloadinterna = RootSeqFlexRbanaZctrlexSgleControl0Zctrlexloadinterna(self._context)
        self.zctrlexpolpidinzclp = RootSeqFlexRbanaZctrlexSgleControl0Zctrlexpolpidinzclp(self._context)
        self.memorygendriveena = RootSeqFlexRbanaZctrlexSgleControl0Memorygendriveena(self._context)
        self.zctrlexinputchan = RootSeqFlexRbanaZctrlexSgleControl0Zctrlexinputchan(self._context)
        self.zctrlexmode = RootSeqFlexRbanaZctrlexSgleControl0Zctrlexmode(self._context)
        self.zctrlexpolpidinfb = RootSeqFlexRbanaZctrlexSgleControl0Zctrlexpolpidinfb(self._context)
        self.stop = RootSeqFlexRbanaZctrlexSgleControl0Stop(self._context)
        self.abort = RootSeqFlexRbanaZctrlexSgleControl0Abort(self._context)
        self.outputmodulationena = RootSeqFlexRbanaZctrlexSgleControl0Outputmodulationena(self._context)
        self.zctrlexpolcomperrlim = RootSeqFlexRbanaZctrlexSgleControl0Zctrlexpolcomperrlim(self._context)
        self.inputiir_vld = RootSeqFlexRbanaZctrlexSgleControl0Inputiir_vld(self._context)
        self.memorygenpositionena = RootSeqFlexRbanaZctrlexSgleControl0Memorygenpositionena(self._context)
        self.setpointmodulationena = RootSeqFlexRbanaZctrlexSgleControl0Setpointmodulationena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.zctrlex.sgle.control0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.zctrlex.sgle.control0.regaddr', int(new_val))


class RootSeqFlexRbanaZctrlexSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex.sgle'
        self.control0 = RootSeqFlexRbanaZctrlexSgleControl0(self._context)
        self.clp_pid_gain_i = RootSeqFlexRbanaZctrlexSgleClp_pid_gain_i(self._context)
        self.setpoint = RootSeqFlexRbanaZctrlexSgleSetpoint(self._context)
        self.rampgenctrlzlimitneg = RootSeqFlexRbanaZctrlexSgleRampgenctrlzlimitneg(self._context)
        self.inputiircoef = RootSeqFlexRbanaZctrlexSgleInputiircoef(self._context)
        self.p1movevalue = RootSeqFlexRbanaZctrlexSgleP1movevalue(self._context)
        self.input = RootSeqFlexRbanaZctrlexSgleInput(self._context)
        self.fb_pid_gain_i = RootSeqFlexRbanaZctrlexSgleFb_pid_gain_i(self._context)
        self.compdcwithz = RootSeqFlexRbanaZctrlexSgleCompdcwithz(self._context)
        self.inputiiraddr = RootSeqFlexRbanaZctrlexSgleInputiiraddr(self._context)
        self.p3moveinc = RootSeqFlexRbanaZctrlexSgleP3moveinc(self._context)
        self.sum = RootSeqFlexRbanaZctrlexSgleSum(self._context)
        self.p1moveinc = RootSeqFlexRbanaZctrlexSgleP1moveinc(self._context)
        self.status = RootSeqFlexRbanaZctrlexSgleStatus(self._context)
        self.rampgenctrlzlimitpos = RootSeqFlexRbanaZctrlexSgleRampgenctrlzlimitpos(self._context)
        self.pidcommand = RootSeqFlexRbanaZctrlexSglePidcommand(self._context)
        self.errorlimit = RootSeqFlexRbanaZctrlexSgleErrorlimit(self._context)
        self.control1 = RootSeqFlexRbanaZctrlexSgleControl1(self._context)
        self.rampgenctrlzout = RootSeqFlexRbanaZctrlexSgleRampgenctrlzout(self._context)
        self.p0movevalue = RootSeqFlexRbanaZctrlexSgleP0movevalue(self._context)
        self.fb_pid_gain_p = RootSeqFlexRbanaZctrlexSgleFb_pid_gain_p(self._context)
        self.p2movevalue = RootSeqFlexRbanaZctrlexSgleP2movevalue(self._context)
        self.zoutlimited = RootSeqFlexRbanaZctrlexSgleZoutlimited(self._context)
        self.phase1realendpos = RootSeqFlexRbanaZctrlexSglePhase1realendpos(self._context)
        self.minzvalue = RootSeqFlexRbanaZctrlexSgleMinzvalue(self._context)
        self.totphasenbr = RootSeqFlexRbanaZctrlexSgleTotphasenbr(self._context)
        self.output = RootSeqFlexRbanaZctrlexSgleOutput(self._context)
        self.phase3realendpos = RootSeqFlexRbanaZctrlexSglePhase3realendpos(self._context)
        self.phase2realendpos = RootSeqFlexRbanaZctrlexSglePhase2realendpos(self._context)
        self.phase0realendpos = RootSeqFlexRbanaZctrlexSglePhase0realendpos(self._context)
        self.p0moveinc = RootSeqFlexRbanaZctrlexSgleP0moveinc(self._context)
        self.error = RootSeqFlexRbanaZctrlexSgleError(self._context)
        self.fb_pid_gain_d = RootSeqFlexRbanaZctrlexSgleFb_pid_gain_d(self._context)
        self.clp_pid_gain_d = RootSeqFlexRbanaZctrlexSgleClp_pid_gain_d(self._context)
        self.clp_pid_gain_p = RootSeqFlexRbanaZctrlexSgleClp_pid_gain_p(self._context)
        self.p2moveinc = RootSeqFlexRbanaZctrlexSgleP2moveinc(self._context)
        self.p3movevalue = RootSeqFlexRbanaZctrlexSgleP3movevalue(self._context)
        self.inputiirout = RootSeqFlexRbanaZctrlexSgleInputiirout(self._context)
        self.currentphase = RootSeqFlexRbanaZctrlexSgleCurrentphase(self._context)
        self.currentrampvalue = RootSeqFlexRbanaZctrlexSgleCurrentrampvalue(self._context)


class RootSeqFlexRbanaZctrlex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.zctrlex'
        self.sgle = RootSeqFlexRbanaZctrlexSgle(self._context)


class RootSeqFlexRbanaAnalyzerTwoDeltafoffs_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.deltafoffs_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.deltafoffs_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.deltafoffs_hi.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoFltrcoeff(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.fltrcoeff'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.fltrcoeff.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.fltrcoeff.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiampkel'
        self.shift = RootSeqFlexRbanaAnalyzerTwoKiampkelShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerTwoKiampkelShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerTwoKiampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoFlag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.flag'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.flag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.flag.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.ctrlbits.ampmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpctrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCtrlbitsPhaseclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.ctrlbits.phaseclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.phaseclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.phaseclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.phaseclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.phaseclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.phaseclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.phaseclearaccu.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCtrlbitsPhasectrl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.ctrlbits.phasectrl'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.phasectrl.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.phasectrl.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.phasectrl.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.phasectrl.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.phasectrl.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.phasectrl.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.ctrlbits.ampclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampclearaccu.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpctrlpositiveaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.ampctrlpositiveaccu.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCtrlbits(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.ctrlbits'
        self.ampctrlpositiveaccu = RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpctrlpositiveaccu(self._context)
        self.ampclearaccu = RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpclearaccu(self._context)
        self.phasectrl = RootSeqFlexRbanaAnalyzerTwoCtrlbitsPhasectrl(self._context)
        self.phaseclearaccu = RootSeqFlexRbanaAnalyzerTwoCtrlbitsPhaseclearaccu(self._context)
        self.ampctrlmode = RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpctrlmode(self._context)
        self.ampmodulation = RootSeqFlexRbanaAnalyzerTwoCtrlbitsAmpmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.ctrlbits.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.ctrlbits.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoLockrangeshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.lockrangeshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.lockrangeshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.lockrangeshift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpphase'
        self.shift = RootSeqFlexRbanaAnalyzerTwoKpphaseShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerTwoKpphaseShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerTwoKpphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpphase.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKpampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kpampkel'
        self.shift = RootSeqFlexRbanaAnalyzerTwoKpampkelShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerTwoKpampkelShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerTwoKpampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kpampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kpampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoModampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.modampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.modampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.modampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoAmplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.amplitude'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.amplitude.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.amplitude.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoModeOpmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.mode.opmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.opmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.opmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.opmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.opmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.opmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.opmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoModePhasedetref(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.mode.phasedetref'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.phasedetref.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.phasedetref.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.phasedetref.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.phasedetref.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.phasedetref.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.phasedetref.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoModeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.mode.input'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.input.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.input.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.input.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.input.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.input.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.input.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoModeAnalyzerinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.mode.analyzerinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.analyzerinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.analyzerinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.analyzerinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.analyzerinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.analyzerinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.analyzerinput.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.mode'
        self.analyzerinput = RootSeqFlexRbanaAnalyzerTwoModeAnalyzerinput(self._context)
        self.input = RootSeqFlexRbanaAnalyzerTwoModeInput(self._context)
        self.phasedetref = RootSeqFlexRbanaAnalyzerTwoModePhasedetref(self._context)
        self.opmode = RootSeqFlexRbanaAnalyzerTwoModeOpmode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.mode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoPhaseshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.phaseshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.phaseshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.phaseshift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoSafetipSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.safetip.safetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.safetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.safetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.safetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.safetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.safetip.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoSafetipSafetipmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.safetip.safetipmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.safetipmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.safetipmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.safetipmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.safetipmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.safetipmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.safetipmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoSafetipSyncorsafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.safetip.syncorsafetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.syncorsafetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.syncorsafetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.syncorsafetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.syncorsafetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.syncorsafetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.syncorsafetip.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoSafetipThresholdmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.safetip.thresholdmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.thresholdmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.thresholdmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.thresholdmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.thresholdmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.thresholdmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.thresholdmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.safetip'
        self.thresholdmode = RootSeqFlexRbanaAnalyzerTwoSafetipThresholdmode(self._context)
        self.syncorsafetip = RootSeqFlexRbanaAnalyzerTwoSafetipSyncorsafetip(self._context)
        self.safetipmode = RootSeqFlexRbanaAnalyzerTwoSafetipSafetipmode(self._context)
        self.safetip = RootSeqFlexRbanaAnalyzerTwoSafetipSafetip(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.safetip.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoDelaycomp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.delaycomp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.delaycomp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.delaycomp.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoSetvalampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.setvalampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.setvalampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.setvalampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoThreshold(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.threshold'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.threshold.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.threshold.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCenterfreq_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.centerfreq_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.centerfreq_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.centerfreq_hi.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoKiphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.kiphase'
        self.shift = RootSeqFlexRbanaAnalyzerTwoKiphaseShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerTwoKiphaseShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerTwoKiphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.kiphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.kiphase.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoDeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.deltaf'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.deltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.deltaf.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoX(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.x'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.x.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.x.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoY(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.y'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.y.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.y.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoPhase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.phase'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.phase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.phase.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoSetptampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.setptampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.setptampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.setptampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoDeltafoffs_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.deltafoffs_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.deltafoffs_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.deltafoffs_lo.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoCenterfreq_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.centerfreq_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.centerfreq_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.centerfreq_lo.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoControl1Fltr_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.control1.fltr_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.fltr_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.fltr_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.fltr_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.fltr_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.fltr_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.fltr_vld.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoControl1Distdeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.control1.distdeltaf'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.distdeltaf.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.distdeltaf.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.distdeltaf.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.distdeltaf.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.distdeltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.distdeltaf.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoControl1Filtaddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.control1.filtaddr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.filtaddr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.filtaddr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.filtaddr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.filtaddr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.filtaddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.filtaddr.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoControl1Outputsourceid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.control1.outputsourceid'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.outputsourceid.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.outputsourceid.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.outputsourceid.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.outputsourceid.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.outputsourceid.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.outputsourceid.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoControl1Clearflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.control1.clearflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.clearflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.clearflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.clearflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.clearflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.clearflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.clearflag.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoControl1Enabledcblock(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.control1.enabledcblock'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.enabledcblock.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.enabledcblock.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.enabledcblock.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.enabledcblock.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.enabledcblock.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.enabledcblock.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoControl1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.control1'
        self.enabledcblock = RootSeqFlexRbanaAnalyzerTwoControl1Enabledcblock(self._context)
        self.clearflag = RootSeqFlexRbanaAnalyzerTwoControl1Clearflag(self._context)
        self.outputsourceid = RootSeqFlexRbanaAnalyzerTwoControl1Outputsourceid(self._context)
        self.filtaddr = RootSeqFlexRbanaAnalyzerTwoControl1Filtaddr(self._context)
        self.distdeltaf = RootSeqFlexRbanaAnalyzerTwoControl1Distdeltaf(self._context)
        self.fltr_vld = RootSeqFlexRbanaAnalyzerTwoControl1Fltr_vld(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.control1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.control1.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwoDisscp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two.disscp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.two.disscp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.two.disscp.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerTwo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.two'
        self.disscp = RootSeqFlexRbanaAnalyzerTwoDisscp(self._context)
        self.control1 = RootSeqFlexRbanaAnalyzerTwoControl1(self._context)
        self.centerfreq_lo = RootSeqFlexRbanaAnalyzerTwoCenterfreq_lo(self._context)
        self.deltafoffs_lo = RootSeqFlexRbanaAnalyzerTwoDeltafoffs_lo(self._context)
        self.setptampkel = RootSeqFlexRbanaAnalyzerTwoSetptampkel(self._context)
        self.phase = RootSeqFlexRbanaAnalyzerTwoPhase(self._context)
        self.y = RootSeqFlexRbanaAnalyzerTwoY(self._context)
        self.x = RootSeqFlexRbanaAnalyzerTwoX(self._context)
        self.deltaf = RootSeqFlexRbanaAnalyzerTwoDeltaf(self._context)
        self.kiphase = RootSeqFlexRbanaAnalyzerTwoKiphase(self._context)
        self.centerfreq_hi = RootSeqFlexRbanaAnalyzerTwoCenterfreq_hi(self._context)
        self.threshold = RootSeqFlexRbanaAnalyzerTwoThreshold(self._context)
        self.setvalampkel = RootSeqFlexRbanaAnalyzerTwoSetvalampkel(self._context)
        self.delaycomp = RootSeqFlexRbanaAnalyzerTwoDelaycomp(self._context)
        self.safetip = RootSeqFlexRbanaAnalyzerTwoSafetip(self._context)
        self.phaseshift = RootSeqFlexRbanaAnalyzerTwoPhaseshift(self._context)
        self.mode = RootSeqFlexRbanaAnalyzerTwoMode(self._context)
        self.amplitude = RootSeqFlexRbanaAnalyzerTwoAmplitude(self._context)
        self.modampkel = RootSeqFlexRbanaAnalyzerTwoModampkel(self._context)
        self.kpampkel = RootSeqFlexRbanaAnalyzerTwoKpampkel(self._context)
        self.kpphase = RootSeqFlexRbanaAnalyzerTwoKpphase(self._context)
        self.lockrangeshift = RootSeqFlexRbanaAnalyzerTwoLockrangeshift(self._context)
        self.ctrlbits = RootSeqFlexRbanaAnalyzerTwoCtrlbits(self._context)
        self.flag = RootSeqFlexRbanaAnalyzerTwoFlag(self._context)
        self.kiampkel = RootSeqFlexRbanaAnalyzerTwoKiampkel(self._context)
        self.fltrcoeff = RootSeqFlexRbanaAnalyzerTwoFltrcoeff(self._context)
        self.deltafoffs_hi = RootSeqFlexRbanaAnalyzerTwoDeltafoffs_hi(self._context)


class RootSeqFlexRbanaAnalyzerOneDeltafoffs_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.deltafoffs_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.deltafoffs_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.deltafoffs_hi.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneFltrcoeff(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.fltrcoeff'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.fltrcoeff.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.fltrcoeff.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiampkel'
        self.shift = RootSeqFlexRbanaAnalyzerOneKiampkelShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerOneKiampkelShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerOneKiampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneFlag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.flag'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.flag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.flag.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpmodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.ctrlbits.ampmodulation'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampmodulation.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampmodulation.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampmodulation.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampmodulation.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampmodulation.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampmodulation.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpctrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCtrlbitsPhaseclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.ctrlbits.phaseclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.phaseclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.phaseclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.phaseclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.phaseclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.phaseclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.phaseclearaccu.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCtrlbitsPhasectrl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.ctrlbits.phasectrl'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.phasectrl.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.phasectrl.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.phasectrl.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.phasectrl.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.phasectrl.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.phasectrl.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpclearaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.ctrlbits.ampclearaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampclearaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampclearaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampclearaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampclearaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampclearaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampclearaccu.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpctrlpositiveaccu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.ampctrlpositiveaccu.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCtrlbits(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.ctrlbits'
        self.ampctrlpositiveaccu = RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpctrlpositiveaccu(self._context)
        self.ampclearaccu = RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpclearaccu(self._context)
        self.phasectrl = RootSeqFlexRbanaAnalyzerOneCtrlbitsPhasectrl(self._context)
        self.phaseclearaccu = RootSeqFlexRbanaAnalyzerOneCtrlbitsPhaseclearaccu(self._context)
        self.ampctrlmode = RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpctrlmode(self._context)
        self.ampmodulation = RootSeqFlexRbanaAnalyzerOneCtrlbitsAmpmodulation(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.ctrlbits.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.ctrlbits.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneLockrangeshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.lockrangeshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.lockrangeshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.lockrangeshift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpphase'
        self.shift = RootSeqFlexRbanaAnalyzerOneKpphaseShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerOneKpphaseShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerOneKpphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpphase.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpampkelFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpampkel.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpampkelShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpampkel.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpampkelShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpampkel.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKpampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kpampkel'
        self.shift = RootSeqFlexRbanaAnalyzerOneKpampkelShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerOneKpampkelShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerOneKpampkelFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kpampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kpampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneModampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.modampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.modampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.modampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneAmplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.amplitude'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.amplitude.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.amplitude.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneModeOpmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.mode.opmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.opmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.opmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.opmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.opmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.opmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.opmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneModePhasedetref(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.mode.phasedetref'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.phasedetref.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.phasedetref.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.phasedetref.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.phasedetref.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.phasedetref.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.phasedetref.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneModeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.mode.input'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.input.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.input.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.input.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.input.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.input.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.input.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneModeAnalyzerinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.mode.analyzerinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.analyzerinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.analyzerinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.analyzerinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.analyzerinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.analyzerinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.analyzerinput.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.mode'
        self.analyzerinput = RootSeqFlexRbanaAnalyzerOneModeAnalyzerinput(self._context)
        self.input = RootSeqFlexRbanaAnalyzerOneModeInput(self._context)
        self.phasedetref = RootSeqFlexRbanaAnalyzerOneModePhasedetref(self._context)
        self.opmode = RootSeqFlexRbanaAnalyzerOneModeOpmode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.mode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOnePhaseshift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.phaseshift'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.phaseshift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.phaseshift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneSafetipSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.safetip.safetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.safetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.safetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.safetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.safetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.safetip.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneSafetipSafetipmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.safetip.safetipmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.safetipmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.safetipmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.safetipmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.safetipmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.safetipmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.safetipmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneSafetipSyncorsafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.safetip.syncorsafetip'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.syncorsafetip.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.syncorsafetip.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.syncorsafetip.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.syncorsafetip.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.syncorsafetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.syncorsafetip.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneSafetipThresholdmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.safetip.thresholdmode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.thresholdmode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.thresholdmode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.thresholdmode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.thresholdmode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.thresholdmode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.thresholdmode.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneSafetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.safetip'
        self.thresholdmode = RootSeqFlexRbanaAnalyzerOneSafetipThresholdmode(self._context)
        self.syncorsafetip = RootSeqFlexRbanaAnalyzerOneSafetipSyncorsafetip(self._context)
        self.safetipmode = RootSeqFlexRbanaAnalyzerOneSafetipSafetipmode(self._context)
        self.safetip = RootSeqFlexRbanaAnalyzerOneSafetipSafetip(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.safetip.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.safetip.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneDelaycomp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.delaycomp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.delaycomp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.delaycomp.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneSetvalampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.setvalampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.setvalampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.setvalampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneThreshold(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.threshold'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.threshold.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.threshold.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCenterfreq_hi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.centerfreq_hi'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.centerfreq_hi.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.centerfreq_hi.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiphaseFactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiphase.factor'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.factor.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.factor.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.factor.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.factor.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.factor.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.factor.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiphaseShiftdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiphase.shiftdirection'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.shiftdirection.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.shiftdirection.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.shiftdirection.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.shiftdirection.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.shiftdirection.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.shiftdirection.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiphaseShift(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiphase.shift'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.shift.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.shift.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.shift.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.shift.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.shift.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.shift.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneKiphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.kiphase'
        self.shift = RootSeqFlexRbanaAnalyzerOneKiphaseShift(self._context)
        self.shiftdirection = RootSeqFlexRbanaAnalyzerOneKiphaseShiftdirection(self._context)
        self.factor = RootSeqFlexRbanaAnalyzerOneKiphaseFactor(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.kiphase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.kiphase.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneDeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.deltaf'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.deltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.deltaf.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneX(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.x'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.x.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.x.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneY(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.y'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.y.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.y.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOnePhase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.phase'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.phase.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.phase.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneSetptampkel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.setptampkel'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.setptampkel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.setptampkel.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneDeltafoffs_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.deltafoffs_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.deltafoffs_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.deltafoffs_lo.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneCenterfreq_lo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.centerfreq_lo'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.centerfreq_lo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.centerfreq_lo.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneControl1Fltr_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.control1.fltr_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.fltr_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.fltr_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.fltr_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.fltr_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.fltr_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.fltr_vld.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneControl1Distdeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.control1.distdeltaf'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.distdeltaf.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.distdeltaf.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.distdeltaf.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.distdeltaf.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.distdeltaf.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.distdeltaf.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneControl1Filtaddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.control1.filtaddr'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.filtaddr.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.filtaddr.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.filtaddr.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.filtaddr.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.filtaddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.filtaddr.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneControl1Outputsourceid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.control1.outputsourceid'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.outputsourceid.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.outputsourceid.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.outputsourceid.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.outputsourceid.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.outputsourceid.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.outputsourceid.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneControl1Clearflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.control1.clearflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.clearflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.clearflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.clearflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.clearflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.clearflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.clearflag.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneControl1Enabledcblock(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.control1.enabledcblock'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.enabledcblock.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.enabledcblock.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.enabledcblock.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.enabledcblock.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.enabledcblock.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.enabledcblock.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneControl1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.control1'
        self.enabledcblock = RootSeqFlexRbanaAnalyzerOneControl1Enabledcblock(self._context)
        self.clearflag = RootSeqFlexRbanaAnalyzerOneControl1Clearflag(self._context)
        self.outputsourceid = RootSeqFlexRbanaAnalyzerOneControl1Outputsourceid(self._context)
        self.filtaddr = RootSeqFlexRbanaAnalyzerOneControl1Filtaddr(self._context)
        self.distdeltaf = RootSeqFlexRbanaAnalyzerOneControl1Distdeltaf(self._context)
        self.fltr_vld = RootSeqFlexRbanaAnalyzerOneControl1Fltr_vld(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.control1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.control1.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOneDisscp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one.disscp'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzer.one.disscp.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzer.one.disscp.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzerOne(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer.one'
        self.disscp = RootSeqFlexRbanaAnalyzerOneDisscp(self._context)
        self.control1 = RootSeqFlexRbanaAnalyzerOneControl1(self._context)
        self.centerfreq_lo = RootSeqFlexRbanaAnalyzerOneCenterfreq_lo(self._context)
        self.deltafoffs_lo = RootSeqFlexRbanaAnalyzerOneDeltafoffs_lo(self._context)
        self.setptampkel = RootSeqFlexRbanaAnalyzerOneSetptampkel(self._context)
        self.phase = RootSeqFlexRbanaAnalyzerOnePhase(self._context)
        self.y = RootSeqFlexRbanaAnalyzerOneY(self._context)
        self.x = RootSeqFlexRbanaAnalyzerOneX(self._context)
        self.deltaf = RootSeqFlexRbanaAnalyzerOneDeltaf(self._context)
        self.kiphase = RootSeqFlexRbanaAnalyzerOneKiphase(self._context)
        self.centerfreq_hi = RootSeqFlexRbanaAnalyzerOneCenterfreq_hi(self._context)
        self.threshold = RootSeqFlexRbanaAnalyzerOneThreshold(self._context)
        self.setvalampkel = RootSeqFlexRbanaAnalyzerOneSetvalampkel(self._context)
        self.delaycomp = RootSeqFlexRbanaAnalyzerOneDelaycomp(self._context)
        self.safetip = RootSeqFlexRbanaAnalyzerOneSafetip(self._context)
        self.phaseshift = RootSeqFlexRbanaAnalyzerOnePhaseshift(self._context)
        self.mode = RootSeqFlexRbanaAnalyzerOneMode(self._context)
        self.amplitude = RootSeqFlexRbanaAnalyzerOneAmplitude(self._context)
        self.modampkel = RootSeqFlexRbanaAnalyzerOneModampkel(self._context)
        self.kpampkel = RootSeqFlexRbanaAnalyzerOneKpampkel(self._context)
        self.kpphase = RootSeqFlexRbanaAnalyzerOneKpphase(self._context)
        self.lockrangeshift = RootSeqFlexRbanaAnalyzerOneLockrangeshift(self._context)
        self.ctrlbits = RootSeqFlexRbanaAnalyzerOneCtrlbits(self._context)
        self.flag = RootSeqFlexRbanaAnalyzerOneFlag(self._context)
        self.kiampkel = RootSeqFlexRbanaAnalyzerOneKiampkel(self._context)
        self.fltrcoeff = RootSeqFlexRbanaAnalyzerOneFltrcoeff(self._context)
        self.deltafoffs_hi = RootSeqFlexRbanaAnalyzerOneDeltafoffs_hi(self._context)


class RootSeqFlexRbanaAnalyzer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzer'
        self.one = RootSeqFlexRbanaAnalyzerOne(self._context)
        self.two = RootSeqFlexRbanaAnalyzerTwo(self._context)


class RootSeqFlexRbanaAnalyzercommonSgleControlHarmoncinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzercommon.sgle.control.harmoncinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzercommon.sgle.control.harmoncinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzercommon.sgle.control.harmoncinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzercommon.sgle.control.harmoncinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzercommon.sgle.control.harmoncinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzercommon.sgle.control.harmoncinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzercommon.sgle.control.harmoncinput.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzercommonSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzercommon.sgle.control'
        self.harmoncinput = RootSeqFlexRbanaAnalyzercommonSgleControlHarmoncinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.analyzercommon.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.analyzercommon.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaAnalyzercommonSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzercommon.sgle'
        self.control = RootSeqFlexRbanaAnalyzercommonSgleControl(self._context)


class RootSeqFlexRbanaAnalyzercommon(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.analyzercommon'
        self.sgle = RootSeqFlexRbanaAnalyzercommonSgle(self._context)


class RootSeqFlexRbanaGpiSgleOdata(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.odata'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.odata.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.odata.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqenaEventmgrstop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena.eventmgrstop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrstop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrstop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrstop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrstop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrstop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrstop.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqenaEventmgrabort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena.eventmgrabort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrabort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrabort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrabort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrabort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrabort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrabort.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqenaRampgentestdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena.rampgentestdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.rampgentestdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.rampgentestdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.rampgentestdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.rampgentestdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.rampgentestdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.rampgentestdone.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqenaUserdigi1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena.userdigi1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.userdigi1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.userdigi1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.userdigi1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.userdigi1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.userdigi1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.userdigi1.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqenaEventmgrdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena.eventmgrdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.eventmgrdone.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqenaRampgenuser4done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena.rampgenuser4done'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.rampgenuser4done.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.rampgenuser4done.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.rampgenuser4done.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.rampgenuser4done.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.rampgenuser4done.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.rampgenuser4done.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqenaUserdigi2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena.userdigi2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.userdigi2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.userdigi2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.userdigi2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.userdigi2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.userdigi2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.userdigi2.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqena'
        self.userdigi2 = RootSeqFlexRbanaGpiSgleIrqenaUserdigi2(self._context)
        self.rampgenuser4done = RootSeqFlexRbanaGpiSgleIrqenaRampgenuser4done(self._context)
        self.eventmgrdone = RootSeqFlexRbanaGpiSgleIrqenaEventmgrdone(self._context)
        self.userdigi1 = RootSeqFlexRbanaGpiSgleIrqenaUserdigi1(self._context)
        self.rampgentestdone = RootSeqFlexRbanaGpiSgleIrqenaRampgentestdone(self._context)
        self.eventmgrabort = RootSeqFlexRbanaGpiSgleIrqenaEventmgrabort(self._context)
        self.eventmgrstop = RootSeqFlexRbanaGpiSgleIrqenaEventmgrstop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqena.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvecEventmgrstop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrstop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrstop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrstop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrstop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrstop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrstop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrstop.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvecEventmgrabort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrabort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrabort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrabort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrabort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrabort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrabort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrabort.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvecRampgentestdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec.rampgentestdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.rampgentestdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.rampgentestdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.rampgentestdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.rampgentestdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.rampgentestdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.rampgentestdone.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvecUserdigi1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec.userdigi1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi1.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvecEventmgrdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.eventmgrdone.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvecRampgenuser4done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec.rampgenuser4done'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.rampgenuser4done.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.rampgenuser4done.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.rampgenuser4done.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.rampgenuser4done.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.rampgenuser4done.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.rampgenuser4done.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvecUserdigi2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec.userdigi2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.userdigi2.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIrqvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.irqvec'
        self.userdigi2 = RootSeqFlexRbanaGpiSgleIrqvecUserdigi2(self._context)
        self.rampgenuser4done = RootSeqFlexRbanaGpiSgleIrqvecRampgenuser4done(self._context)
        self.eventmgrdone = RootSeqFlexRbanaGpiSgleIrqvecEventmgrdone(self._context)
        self.userdigi1 = RootSeqFlexRbanaGpiSgleIrqvecUserdigi1(self._context)
        self.rampgentestdone = RootSeqFlexRbanaGpiSgleIrqvecRampgentestdone(self._context)
        self.eventmgrabort = RootSeqFlexRbanaGpiSgleIrqvecEventmgrabort(self._context)
        self.eventmgrstop = RootSeqFlexRbanaGpiSgleIrqvecEventmgrstop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.irqvec.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.irqvec.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdataEventmgrstop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata.eventmgrstop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrstop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrstop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrstop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrstop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrstop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrstop.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdataEventmgrabort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata.eventmgrabort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrabort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrabort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrabort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrabort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrabort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrabort.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdataRampgentestdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata.rampgentestdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.rampgentestdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.rampgentestdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.rampgentestdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.rampgentestdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.rampgentestdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.rampgentestdone.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdataUserdigi1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata.userdigi1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.userdigi1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.userdigi1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.userdigi1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.userdigi1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.userdigi1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.userdigi1.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdataEventmgrdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata.eventmgrdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.eventmgrdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.eventmgrdone.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdataRampgenuser4done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata.rampgenuser4done'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.rampgenuser4done.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.rampgenuser4done.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.rampgenuser4done.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.rampgenuser4done.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.rampgenuser4done.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.rampgenuser4done.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdataUserdigi2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata.userdigi2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.userdigi2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.userdigi2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.userdigi2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.userdigi2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.userdigi2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.userdigi2.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgleIdata(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle.idata'
        self.userdigi2 = RootSeqFlexRbanaGpiSgleIdataUserdigi2(self._context)
        self.rampgenuser4done = RootSeqFlexRbanaGpiSgleIdataRampgenuser4done(self._context)
        self.eventmgrdone = RootSeqFlexRbanaGpiSgleIdataEventmgrdone(self._context)
        self.userdigi1 = RootSeqFlexRbanaGpiSgleIdataUserdigi1(self._context)
        self.rampgentestdone = RootSeqFlexRbanaGpiSgleIdataRampgentestdone(self._context)
        self.eventmgrabort = RootSeqFlexRbanaGpiSgleIdataEventmgrabort(self._context)
        self.eventmgrstop = RootSeqFlexRbanaGpiSgleIdataEventmgrstop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.gpi.sgle.idata.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.gpi.sgle.idata.regaddr', int(new_val))


class RootSeqFlexRbanaGpiSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi.sgle'
        self.idata = RootSeqFlexRbanaGpiSgleIdata(self._context)
        self.irqvec = RootSeqFlexRbanaGpiSgleIrqvec(self._context)
        self.irqena = RootSeqFlexRbanaGpiSgleIrqena(self._context)
        self.odata = RootSeqFlexRbanaGpiSgleOdata(self._context)


class RootSeqFlexRbanaGpi(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.gpi'
        self.sgle = RootSeqFlexRbanaGpiSgle(self._context)


class RootSeqFlexRbanaSeqSgleA(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.a'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.a.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.a.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleSeqreg(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.seqreg'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.seqreg.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.seqreg.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleBit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.bit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.bit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.bit.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleB(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.b'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.b.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.b.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleM(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.m'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.m.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.m.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleAddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.addr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.addr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.addr.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleInstrptr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.instrptr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.instrptr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.instrptr.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleControlStep(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.control.step'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.step.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.step.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.step.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.step.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.step.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.step.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.control'
        self.start = RootSeqFlexRbanaSeqSgleControlStart(self._context)
        self.abort = RootSeqFlexRbanaSeqSgleControlAbort(self._context)
        self.stop = RootSeqFlexRbanaSeqSgleControlStop(self._context)
        self.step = RootSeqFlexRbanaSeqSgleControlStep(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleStatusReaderror(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.status.readerror'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.status.readerror.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.status.readerror.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.status.readerror.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.status.readerror.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.status.readerror.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.status.readerror.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleStatusRunning(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.status.running'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.status.running.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.status.running.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.status.running.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.status.running.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.status.running.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.status.running.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.status'
        self.running = RootSeqFlexRbanaSeqSgleStatusRunning(self._context)
        self.readerror = RootSeqFlexRbanaSeqSgleStatusReaderror(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.status.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleSum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.sum'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.sum.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.sum.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgleData(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle.data'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.seq.sgle.data.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.seq.sgle.data.regaddr', int(new_val))


class RootSeqFlexRbanaSeqSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq.sgle'
        self.data = RootSeqFlexRbanaSeqSgleData(self._context)
        self.sum = RootSeqFlexRbanaSeqSgleSum(self._context)
        self.status = RootSeqFlexRbanaSeqSgleStatus(self._context)
        self.control = RootSeqFlexRbanaSeqSgleControl(self._context)
        self.instrptr = RootSeqFlexRbanaSeqSgleInstrptr(self._context)
        self.addr = RootSeqFlexRbanaSeqSgleAddr(self._context)
        self.m = RootSeqFlexRbanaSeqSgleM(self._context)
        self.b = RootSeqFlexRbanaSeqSgleB(self._context)
        self.bit = RootSeqFlexRbanaSeqSgleBit(self._context)
        self.seqreg = RootSeqFlexRbanaSeqSgleSeqreg(self._context)
        self.a = RootSeqFlexRbanaSeqSgleA(self._context)


class RootSeqFlexRbanaSeq(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.seq'
        self.sgle = RootSeqFlexRbanaSeqSgle(self._context)


class RootSeqFlexRbanaPidPidyStatusReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.status.reachedmax'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachedmax.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachedmax.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachedmax.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachedmax.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachedmax.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachedmax.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyStatusReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.status.reachedmin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachedmin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachedmin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachedmin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachedmin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachedmin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachedmin.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyStatusInternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.status.internaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.internaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.internaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.internaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.internaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.internaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.internaloaded.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyStatusReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.status.reachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.reachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.reachederrlim.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.status'
        self.reachederrlim = RootSeqFlexRbanaPidPidyStatusReachederrlim(self._context)
        self.internaloaded = RootSeqFlexRbanaPidPidyStatusInternaloaded(self._context)
        self.reachedmin = RootSeqFlexRbanaPidPidyStatusReachedmin(self._context)
        self.reachedmax = RootSeqFlexRbanaPidPidyStatusReachedmax(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.status.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyGain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.gain_i.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyPreloadvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.preloadvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.preloadvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.preloadvalue.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.minvalue.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.offset.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.maxvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.maxvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.maxvalue.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidySlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.slope'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.slope.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.slope.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlMemorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.memorygendriveena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlMemorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.memorygenpositionena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlModena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.modena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.modena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.modena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.modena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.modena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.modena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.modena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlOutsel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.outsel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.outsel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.outsel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.outsel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.outsel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.outsel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.outsel.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlPidinputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.pidinputsetpoint'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.pidinputsetpoint.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.pidinputsetpoint.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.pidinputsetpoint.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.pidinputsetpoint.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.pidinputsetpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.pidinputsetpoint.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlPidinputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.pidinputactual'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.pidinputactual.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.pidinputactual.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.pidinputactual.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.pidinputactual.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.pidinputactual.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.pidinputactual.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlPolpidin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.polpidin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.polpidin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.polpidin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.polpidin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.polpidin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.polpidin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.polpidin.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlPolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.polcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.polcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.polcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.polcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.polcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.polcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.polcomperrlim.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlLoadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.loadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.loadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.loadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.loadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.loadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.loadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.loadinterna.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControlMedianfilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control.medianfilterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.medianfilterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.medianfilterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.medianfilterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.medianfilterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.medianfilterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.medianfilterena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.control'
        self.medianfilterena = RootSeqFlexRbanaPidPidyControlMedianfilterena(self._context)
        self.loadinterna = RootSeqFlexRbanaPidPidyControlLoadinterna(self._context)
        self.polcomperrlim = RootSeqFlexRbanaPidPidyControlPolcomperrlim(self._context)
        self.polpidin = RootSeqFlexRbanaPidPidyControlPolpidin(self._context)
        self.pidinputactual = RootSeqFlexRbanaPidPidyControlPidinputactual(self._context)
        self.mode = RootSeqFlexRbanaPidPidyControlMode(self._context)
        self.pidinputsetpoint = RootSeqFlexRbanaPidPidyControlPidinputsetpoint(self._context)
        self.outsel = RootSeqFlexRbanaPidPidyControlOutsel(self._context)
        self.modena = RootSeqFlexRbanaPidPidyControlModena(self._context)
        self.memorygenpositionena = RootSeqFlexRbanaPidPidyControlMemorygenpositionena(self._context)
        self.memorygendriveena = RootSeqFlexRbanaPidPidyControlMemorygendriveena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.control.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyGain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.gain_d.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyGain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.gain_p.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyConversion(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.conversion'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.conversion.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.conversion.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidyErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidy.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidy.errorlimit.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidy'
        self.errorlimit = RootSeqFlexRbanaPidPidyErrorlimit(self._context)
        self.conversion = RootSeqFlexRbanaPidPidyConversion(self._context)
        self.gain_p = RootSeqFlexRbanaPidPidyGain_p(self._context)
        self.gain_d = RootSeqFlexRbanaPidPidyGain_d(self._context)
        self.control = RootSeqFlexRbanaPidPidyControl(self._context)
        self.slope = RootSeqFlexRbanaPidPidySlope(self._context)
        self.maxvalue = RootSeqFlexRbanaPidPidyMaxvalue(self._context)
        self.offset = RootSeqFlexRbanaPidPidyOffset(self._context)
        self.minvalue = RootSeqFlexRbanaPidPidyMinvalue(self._context)
        self.preloadvalue = RootSeqFlexRbanaPidPidyPreloadvalue(self._context)
        self.gain_i = RootSeqFlexRbanaPidPidyGain_i(self._context)
        self.status = RootSeqFlexRbanaPidPidyStatus(self._context)


class RootSeqFlexRbanaPidPidxStatusReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.status.reachedmax'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachedmax.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachedmax.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachedmax.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachedmax.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachedmax.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachedmax.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxStatusReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.status.reachedmin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachedmin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachedmin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachedmin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachedmin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachedmin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachedmin.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxStatusInternaloaded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.status.internaloaded'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.internaloaded.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.internaloaded.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.internaloaded.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.internaloaded.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.internaloaded.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.internaloaded.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxStatusReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.status.reachederrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachederrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachederrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachederrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachederrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.reachederrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.reachederrlim.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.status'
        self.reachederrlim = RootSeqFlexRbanaPidPidxStatusReachederrlim(self._context)
        self.internaloaded = RootSeqFlexRbanaPidPidxStatusInternaloaded(self._context)
        self.reachedmin = RootSeqFlexRbanaPidPidxStatusReachedmin(self._context)
        self.reachedmax = RootSeqFlexRbanaPidPidxStatusReachedmax(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.status.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxGain_i(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.gain_i'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.gain_i.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.gain_i.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxPreloadvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.preloadvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.preloadvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.preloadvalue.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.minvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.minvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.minvalue.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.offset'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.offset.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.offset.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.maxvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.maxvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.maxvalue.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.slope'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.slope.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.slope.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlMemorygendriveena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.memorygendriveena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.memorygendriveena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.memorygendriveena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.memorygendriveena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.memorygendriveena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.memorygendriveena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.memorygendriveena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlMemorygenpositionena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.memorygenpositionena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.memorygenpositionena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.memorygenpositionena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.memorygenpositionena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.memorygenpositionena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.memorygenpositionena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.memorygenpositionena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlModena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.modena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.modena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.modena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.modena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.modena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.modena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.modena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlOutsel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.outsel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.outsel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.outsel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.outsel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.outsel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.outsel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.outsel.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlPidinputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.pidinputsetpoint'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.pidinputsetpoint.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.pidinputsetpoint.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.pidinputsetpoint.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.pidinputsetpoint.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.pidinputsetpoint.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.pidinputsetpoint.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlPidinputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.pidinputactual'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.pidinputactual.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.pidinputactual.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.pidinputactual.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.pidinputactual.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.pidinputactual.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.pidinputactual.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlPolpidin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.polpidin'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.polpidin.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.polpidin.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.polpidin.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.polpidin.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.polpidin.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.polpidin.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlPolcomperrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.polcomperrlim'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.polcomperrlim.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.polcomperrlim.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.polcomperrlim.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.polcomperrlim.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.polcomperrlim.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.polcomperrlim.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlLoadinterna(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.loadinterna'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.loadinterna.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.loadinterna.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.loadinterna.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.loadinterna.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.loadinterna.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.loadinterna.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControlMedianfilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control.medianfilterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.medianfilterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.medianfilterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.medianfilterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.medianfilterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.medianfilterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.medianfilterena.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.control'
        self.medianfilterena = RootSeqFlexRbanaPidPidxControlMedianfilterena(self._context)
        self.loadinterna = RootSeqFlexRbanaPidPidxControlLoadinterna(self._context)
        self.polcomperrlim = RootSeqFlexRbanaPidPidxControlPolcomperrlim(self._context)
        self.polpidin = RootSeqFlexRbanaPidPidxControlPolpidin(self._context)
        self.pidinputactual = RootSeqFlexRbanaPidPidxControlPidinputactual(self._context)
        self.mode = RootSeqFlexRbanaPidPidxControlMode(self._context)
        self.pidinputsetpoint = RootSeqFlexRbanaPidPidxControlPidinputsetpoint(self._context)
        self.outsel = RootSeqFlexRbanaPidPidxControlOutsel(self._context)
        self.modena = RootSeqFlexRbanaPidPidxControlModena(self._context)
        self.memorygenpositionena = RootSeqFlexRbanaPidPidxControlMemorygenpositionena(self._context)
        self.memorygendriveena = RootSeqFlexRbanaPidPidxControlMemorygendriveena(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.control.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxGain_d(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.gain_d'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.gain_d.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.gain_d.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxGain_p(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.gain_p'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.gain_p.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.gain_p.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxConversion(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.conversion'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.conversion.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.conversion.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidxErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx.errorlimit'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.pid.pidx.errorlimit.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.pid.pidx.errorlimit.regaddr', int(new_val))


class RootSeqFlexRbanaPidPidx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid.pidx'
        self.errorlimit = RootSeqFlexRbanaPidPidxErrorlimit(self._context)
        self.conversion = RootSeqFlexRbanaPidPidxConversion(self._context)
        self.gain_p = RootSeqFlexRbanaPidPidxGain_p(self._context)
        self.gain_d = RootSeqFlexRbanaPidPidxGain_d(self._context)
        self.control = RootSeqFlexRbanaPidPidxControl(self._context)
        self.slope = RootSeqFlexRbanaPidPidxSlope(self._context)
        self.maxvalue = RootSeqFlexRbanaPidPidxMaxvalue(self._context)
        self.offset = RootSeqFlexRbanaPidPidxOffset(self._context)
        self.minvalue = RootSeqFlexRbanaPidPidxMinvalue(self._context)
        self.preloadvalue = RootSeqFlexRbanaPidPidxPreloadvalue(self._context)
        self.gain_i = RootSeqFlexRbanaPidPidxGain_i(self._context)
        self.status = RootSeqFlexRbanaPidPidxStatus(self._context)


class RootSeqFlexRbanaPid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.pid'
        self.pidx = RootSeqFlexRbanaPidPidx(self._context)
        self.pidy = RootSeqFlexRbanaPidPidy(self._context)


class RootSeqFlexRbanaRegaddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.regaddr'


class RootSeqFlexRbanaDatasamplerSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleStatusEventcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.status.eventcount'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.status.eventcount.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.status.eventcount.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.status.eventcount.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.status.eventcount.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.status.eventcount.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.status.eventcount.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.status'
        self.eventcount = RootSeqFlexRbanaDatasamplerSgleStatusEventcount(self._context)
        self.busy = RootSeqFlexRbanaDatasamplerSgleStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.status.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleDatapoint0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.datapoint0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.datapoint0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.datapoint0.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleDatapoint3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.datapoint3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.datapoint3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.datapoint3.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleValue2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.value2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.value2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.value2.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleEvents(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.events'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.events.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.events.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleTimestamplastlsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.timestamplastlsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.timestamplastlsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.timestamplastlsb.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleDatapoint2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.datapoint2'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.datapoint2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.datapoint2.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleControlSyncwithzctrlex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.control.syncwithzctrlex'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.syncwithzctrlex.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.syncwithzctrlex.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.syncwithzctrlex.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.syncwithzctrlex.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.syncwithzctrlex.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.syncwithzctrlex.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleControlFlushfifo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.control.flushfifo'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.flushfifo.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.flushfifo.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.flushfifo.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.flushfifo.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.flushfifo.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.flushfifo.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.control'
        self.start = RootSeqFlexRbanaDatasamplerSgleControlStart(self._context)
        self.flushfifo = RootSeqFlexRbanaDatasamplerSgleControlFlushfifo(self._context)
        self.abort = RootSeqFlexRbanaDatasamplerSgleControlAbort(self._context)
        self.stop = RootSeqFlexRbanaDatasamplerSgleControlStop(self._context)
        self.mode = RootSeqFlexRbanaDatasamplerSgleControlMode(self._context)
        self.syncwithzctrlex = RootSeqFlexRbanaDatasamplerSgleControlSyncwithzctrlex(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleTimestampfirstmsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.timestampfirstmsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.timestampfirstmsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.timestampfirstmsb.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleTimestamplastmsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.timestamplastmsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.timestamplastmsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.timestamplastmsb.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleValue0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.value0'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.value0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.value0.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleValue1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.value1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.value1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.value1.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSglePhasenbr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.phasenbr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.phasenbr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.phasenbr.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleTimestampfirstlsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.timestampfirstlsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.timestampfirstlsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.timestampfirstlsb.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleDatapoint1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.datapoint1'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.datapoint1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.datapoint1.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgleValue3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle.value3'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datasampler.sgle.value3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datasampler.sgle.value3.regaddr', int(new_val))


class RootSeqFlexRbanaDatasamplerSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler.sgle'
        self.value3 = RootSeqFlexRbanaDatasamplerSgleValue3(self._context)
        self.datapoint1 = RootSeqFlexRbanaDatasamplerSgleDatapoint1(self._context)
        self.timestampfirstlsb = RootSeqFlexRbanaDatasamplerSgleTimestampfirstlsb(self._context)
        self.phasenbr = RootSeqFlexRbanaDatasamplerSglePhasenbr(self._context)
        self.value1 = RootSeqFlexRbanaDatasamplerSgleValue1(self._context)
        self.value0 = RootSeqFlexRbanaDatasamplerSgleValue0(self._context)
        self.timestamplastmsb = RootSeqFlexRbanaDatasamplerSgleTimestamplastmsb(self._context)
        self.timestampfirstmsb = RootSeqFlexRbanaDatasamplerSgleTimestampfirstmsb(self._context)
        self.control = RootSeqFlexRbanaDatasamplerSgleControl(self._context)
        self.datapoint2 = RootSeqFlexRbanaDatasamplerSgleDatapoint2(self._context)
        self.timestamplastlsb = RootSeqFlexRbanaDatasamplerSgleTimestamplastlsb(self._context)
        self.events = RootSeqFlexRbanaDatasamplerSgleEvents(self._context)
        self.value2 = RootSeqFlexRbanaDatasamplerSgleValue2(self._context)
        self.datapoint3 = RootSeqFlexRbanaDatasamplerSgleDatapoint3(self._context)
        self.datapoint0 = RootSeqFlexRbanaDatasamplerSgleDatapoint0(self._context)
        self.status = RootSeqFlexRbanaDatasamplerSgleStatus(self._context)


class RootSeqFlexRbanaDatasampler(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datasampler'
        self.sgle = RootSeqFlexRbanaDatasamplerSgle(self._context)


class RootSeqFlexRbanaTimerProc0Events(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.events'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.events.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.events.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0StatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0StatusEventcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.status.eventcount'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.status.eventcount.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.status.eventcount.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.status.eventcount.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.status.eventcount.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.status.eventcount.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.status.eventcount.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.status'
        self.eventcount = RootSeqFlexRbanaTimerProc0StatusEventcount(self._context)
        self.busy = RootSeqFlexRbanaTimerProc0StatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.status.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0Value(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.value.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0ControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0ControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0ControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0.control'
        self.start = RootSeqFlexRbanaTimerProc0ControlStart(self._context)
        self.abort = RootSeqFlexRbanaTimerProc0ControlAbort(self._context)
        self.stop = RootSeqFlexRbanaTimerProc0ControlStop(self._context)
        self.mode = RootSeqFlexRbanaTimerProc0ControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.proc0.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.proc0.control.regaddr', int(new_val))


class RootSeqFlexRbanaTimerProc0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.proc0'
        self.control = RootSeqFlexRbanaTimerProc0Control(self._context)
        self.value = RootSeqFlexRbanaTimerProc0Value(self._context)
        self.status = RootSeqFlexRbanaTimerProc0Status(self._context)
        self.events = RootSeqFlexRbanaTimerProc0Events(self._context)


class RootSeqFlexRbanaTimerDbg1Events(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.events'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.events.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.events.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1StatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1StatusEventcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.status.eventcount'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.status.eventcount.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.status.eventcount.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.status.eventcount.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.status.eventcount.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.status.eventcount.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.status.eventcount.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1Status(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.status'
        self.eventcount = RootSeqFlexRbanaTimerDbg1StatusEventcount(self._context)
        self.busy = RootSeqFlexRbanaTimerDbg1StatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.status.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1Value(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.value'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.value.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.value.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1ControlMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.control.mode'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.mode.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.mode.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.mode.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.mode.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.mode.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.mode.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1ControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1ControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1ControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1.control'
        self.start = RootSeqFlexRbanaTimerDbg1ControlStart(self._context)
        self.abort = RootSeqFlexRbanaTimerDbg1ControlAbort(self._context)
        self.stop = RootSeqFlexRbanaTimerDbg1ControlStop(self._context)
        self.mode = RootSeqFlexRbanaTimerDbg1ControlMode(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.timer.dbg1.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.timer.dbg1.control.regaddr', int(new_val))


class RootSeqFlexRbanaTimerDbg1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer.dbg1'
        self.control = RootSeqFlexRbanaTimerDbg1Control(self._context)
        self.value = RootSeqFlexRbanaTimerDbg1Value(self._context)
        self.status = RootSeqFlexRbanaTimerDbg1Status(self._context)
        self.events = RootSeqFlexRbanaTimerDbg1Events(self._context)


class RootSeqFlexRbanaTimer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.timer'
        self.dbg1 = RootSeqFlexRbanaTimerDbg1(self._context)
        self.proc0 = RootSeqFlexRbanaTimerProc0(self._context)


class RootSeqFlexRbanaDpointfltrSgleStatusFifolevel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.status.fifolevel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifolevel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifolevel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifolevel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifolevel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifolevel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifolevel.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleStatusFifofullflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.status.fifofullflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifofullflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifofullflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifofullflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifofullflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifofullflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifofullflag.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleStatusFifoemptyflag(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.status.fifoemptyflag'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifoemptyflag.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifoemptyflag.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifoemptyflag.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifoemptyflag.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.fifoemptyflag.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.fifoemptyflag.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleStatusAcqdone(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.status.acqdone'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.acqdone.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.acqdone.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.acqdone.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.acqdone.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.acqdone.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.acqdone.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleStatusAcqinprogress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.status.acqinprogress'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.acqinprogress.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.acqinprogress.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.acqinprogress.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.acqinprogress.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.acqinprogress.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.acqinprogress.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.status'
        self.acqinprogress = RootSeqFlexRbanaDpointfltrSgleStatusAcqinprogress(self._context)
        self.acqdone = RootSeqFlexRbanaDpointfltrSgleStatusAcqdone(self._context)
        self.fifoemptyflag = RootSeqFlexRbanaDpointfltrSgleStatusFifoemptyflag(self._context)
        self.fifofullflag = RootSeqFlexRbanaDpointfltrSgleStatusFifofullflag(self._context)
        self.fifolevel = RootSeqFlexRbanaDpointfltrSgleStatusFifolevel(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.status.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleFircoeffs(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.fircoeffs'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.fircoeffs.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.fircoeffs.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin4Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin4.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin4.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin4.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin4.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin4.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin4.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin4.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin4'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin4Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin4.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin3Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin3.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin3.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin3.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin3.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin3.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin3.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin3.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin3'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin3Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin3.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin5Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin5.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin5.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin5.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin5.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin5.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin5.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin5.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin5'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin5Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin5.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin5.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin0Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin0.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin0.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin0.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin0.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin0.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin0.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin0.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin0'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin0Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin0.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleControlFilterstage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.control.filterstage'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.control.filterstage.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.control.filterstage.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.control.filterstage.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.control.filterstage.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.control.filterstage.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.control.filterstage.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleControlSamplemask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.control.samplemask'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.control.samplemask.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.control.samplemask.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.control.samplemask.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.control.samplemask.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.control.samplemask.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.control.samplemask.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.control'
        self.samplemask = RootSeqFlexRbanaDpointfltrSgleControlSamplemask(self._context)
        self.filterstage = RootSeqFlexRbanaDpointfltrSgleControlFilterstage(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin6Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin6.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin6.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin6.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin6.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin6.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin6.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin6.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin6'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin6Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin6.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin6.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin1Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin1.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin1.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin1.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin1.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin1.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin1.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin1.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin1'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin1Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin1.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin2Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin2.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin2.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin2.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin2.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin2.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin2.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin2.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin2'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin2Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin2.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleData(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.data'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.data.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.data.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin7Srcchan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin7.srcchan'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin7.srcchan.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin7.srcchan.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin7.srcchan.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin7.srcchan.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin7.srcchan.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin7.srcchan.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgleChanin7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle.chanin7'
        self.srcchan = RootSeqFlexRbanaDpointfltrSgleChanin7Srcchan(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.dpointfltr.sgle.chanin7.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.dpointfltr.sgle.chanin7.regaddr', int(new_val))


class RootSeqFlexRbanaDpointfltrSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr.sgle'
        self.chanin7 = RootSeqFlexRbanaDpointfltrSgleChanin7(self._context)
        self.data = RootSeqFlexRbanaDpointfltrSgleData(self._context)
        self.chanin2 = RootSeqFlexRbanaDpointfltrSgleChanin2(self._context)
        self.chanin1 = RootSeqFlexRbanaDpointfltrSgleChanin1(self._context)
        self.chanin6 = RootSeqFlexRbanaDpointfltrSgleChanin6(self._context)
        self.control = RootSeqFlexRbanaDpointfltrSgleControl(self._context)
        self.chanin0 = RootSeqFlexRbanaDpointfltrSgleChanin0(self._context)
        self.chanin5 = RootSeqFlexRbanaDpointfltrSgleChanin5(self._context)
        self.chanin3 = RootSeqFlexRbanaDpointfltrSgleChanin3(self._context)
        self.chanin4 = RootSeqFlexRbanaDpointfltrSgleChanin4(self._context)
        self.fircoeffs = RootSeqFlexRbanaDpointfltrSgleFircoeffs(self._context)
        self.status = RootSeqFlexRbanaDpointfltrSgleStatus(self._context)


class RootSeqFlexRbanaDpointfltr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.dpointfltr'
        self.sgle = RootSeqFlexRbanaDpointfltrSgle(self._context)


class RootSeqFlexRbanaDatacaptureSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.status'
        self.busy = RootSeqFlexRbanaDatacaptureSgleStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.status.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleTimestampfirstmsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.timestampfirstmsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.timestampfirstmsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.timestampfirstmsb.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin6'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin6.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin6.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin6.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin6.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin6.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin6.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin4'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin4.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin4.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin4.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin4.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin4.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin4.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin5(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin5'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin5.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin5.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin5.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin5.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin5.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin5.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin7'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin7.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin7.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin7.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin7.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin7.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.selectin7.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires1'
        self.selectin7 = RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin7(self._context)
        self.selectin5 = RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin5(self._context)
        self.selectin4 = RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin4(self._context)
        self.selectin6 = RootSeqFlexRbanaDatacaptureSgleSelecthires1Selectin6(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires1.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin2'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin2.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin2.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin2.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin2.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin2.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin2.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin1.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin0'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin0.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin0.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin0.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin0.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin0.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin3'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin3.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin3.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin3.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin3.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin3.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.selectin3.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleSelecthires0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.selecthires0'
        self.selectin3 = RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin3(self._context)
        self.selectin0 = RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin0(self._context)
        self.selectin1 = RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin1(self._context)
        self.selectin2 = RootSeqFlexRbanaDatacaptureSgleSelecthires0Selectin2(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.selecthires0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.selecthires0.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleTimestampfirstlsb(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.timestampfirstlsb'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.timestampfirstlsb.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.timestampfirstlsb.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlEnablefastcapture(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.enablefastcapture'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.enablefastcapture.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.enablefastcapture.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.enablefastcapture.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.enablefastcapture.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.enablefastcapture.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.enablefastcapture.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlFastdivider(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.fastdivider'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.fastdivider.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.fastdivider.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.fastdivider.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.fastdivider.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.fastdivider.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.fastdivider.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlSelectfastin0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.selectfastin0'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.selectfastin0.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.selectfastin0.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.selectfastin0.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.selectfastin0.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.selectfastin0.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.selectfastin0.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlSelectfastin1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.selectfastin1'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.selectfastin1.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.selectfastin1.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.selectfastin1.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.selectfastin1.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.selectfastin1.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.selectfastin1.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlEnablehirescapture(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.enablehirescapture'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.enablehirescapture.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.enablehirescapture.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.enablehirescapture.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.enablehirescapture.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.enablehirescapture.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.enablehirescapture.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlChanmaskfast(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.chanmaskfast'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.chanmaskfast.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.chanmaskfast.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.chanmaskfast.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.chanmaskfast.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.chanmaskfast.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.chanmaskfast.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControlChanmaskhires(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control.chanmaskhires'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.chanmaskhires.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.chanmaskhires.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.chanmaskhires.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.chanmaskhires.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.chanmaskhires.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.chanmaskhires.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle.control'
        self.chanmaskhires = RootSeqFlexRbanaDatacaptureSgleControlChanmaskhires(self._context)
        self.chanmaskfast = RootSeqFlexRbanaDatacaptureSgleControlChanmaskfast(self._context)
        self.enablehirescapture = RootSeqFlexRbanaDatacaptureSgleControlEnablehirescapture(self._context)
        self.start = RootSeqFlexRbanaDatacaptureSgleControlStart(self._context)
        self.abort = RootSeqFlexRbanaDatacaptureSgleControlAbort(self._context)
        self.stop = RootSeqFlexRbanaDatacaptureSgleControlStop(self._context)
        self.selectfastin1 = RootSeqFlexRbanaDatacaptureSgleControlSelectfastin1(self._context)
        self.selectfastin0 = RootSeqFlexRbanaDatacaptureSgleControlSelectfastin0(self._context)
        self.fastdivider = RootSeqFlexRbanaDatacaptureSgleControlFastdivider(self._context)
        self.enablefastcapture = RootSeqFlexRbanaDatacaptureSgleControlEnablefastcapture(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.datacapture.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.datacapture.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaDatacaptureSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture.sgle'
        self.control = RootSeqFlexRbanaDatacaptureSgleControl(self._context)
        self.timestampfirstlsb = RootSeqFlexRbanaDatacaptureSgleTimestampfirstlsb(self._context)
        self.selecthires0 = RootSeqFlexRbanaDatacaptureSgleSelecthires0(self._context)
        self.selecthires1 = RootSeqFlexRbanaDatacaptureSgleSelecthires1(self._context)
        self.timestampfirstmsb = RootSeqFlexRbanaDatacaptureSgleTimestampfirstmsb(self._context)
        self.status = RootSeqFlexRbanaDatacaptureSgleStatus(self._context)


class RootSeqFlexRbanaDatacapture(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.datacapture'
        self.sgle = RootSeqFlexRbanaDatacaptureSgle(self._context)


class RootSeqFlexRbanaMemorysignalgenSgleStatusBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.status.busy'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.busy.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.busy.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.busy.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.busy.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.busy.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.busy.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleStatusFifolevel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.status.fifolevel'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.fifolevel.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.fifolevel.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.fifolevel.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.fifolevel.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.fifolevel.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.fifolevel.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleStatusUnderrun(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.status.underrun'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.underrun.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.underrun.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.underrun.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.underrun.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.underrun.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.underrun.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleStatusEndreached(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.status.endreached'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.endreached.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.endreached.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.endreached.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.endreached.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.endreached.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.endreached.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.status'
        self.endreached = RootSeqFlexRbanaMemorysignalgenSgleStatusEndreached(self._context)
        self.underrun = RootSeqFlexRbanaMemorysignalgenSgleStatusUnderrun(self._context)
        self.fifolevel = RootSeqFlexRbanaMemorysignalgenSgleStatusFifolevel(self._context)
        self.busy = RootSeqFlexRbanaMemorysignalgenSgleStatusBusy(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.status.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.status.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleSampleno(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.sampleno'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.sampleno.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.sampleno.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleSamplecnt(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.samplecnt'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.samplecnt.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.samplecnt.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleRvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.rvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.rvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.rvalue.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleIncrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.increment'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.increment.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.increment.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleWvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.wvalue'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.wvalue.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.wvalue.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleOut(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.out'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.out.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.out.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlStop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.stop'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.stop.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.stop.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.stop.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.stop.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.stop.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.stop.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlAddress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.address'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.address.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.address.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.address.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.address.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.address.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.address.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlAbort(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.abort'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.abort.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.abort.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.abort.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.abort.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.abort.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.abort.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlJoin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.join'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.join.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.join.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.join.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.join.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.join.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.join.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlOutaddress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.outaddress'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.outaddress.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.outaddress.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.outaddress.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.outaddress.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.outaddress.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.outaddress.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlLinear(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.linear'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.linear.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.linear.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.linear.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.linear.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.linear.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.linear.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlEnable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.enable'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.enable.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.enable.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.enable.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.enable.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.enable.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.enable.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlClear(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.clear'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.clear.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.clear.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.clear.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.clear.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.clear.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.clear.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControlStart(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control.start'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.start.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.start.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.start.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.start.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.start.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.start.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgleControl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle.control'
        self.start = RootSeqFlexRbanaMemorysignalgenSgleControlStart(self._context)
        self.clear = RootSeqFlexRbanaMemorysignalgenSgleControlClear(self._context)
        self.enable = RootSeqFlexRbanaMemorysignalgenSgleControlEnable(self._context)
        self.linear = RootSeqFlexRbanaMemorysignalgenSgleControlLinear(self._context)
        self.outaddress = RootSeqFlexRbanaMemorysignalgenSgleControlOutaddress(self._context)
        self.join = RootSeqFlexRbanaMemorysignalgenSgleControlJoin(self._context)
        self.abort = RootSeqFlexRbanaMemorysignalgenSgleControlAbort(self._context)
        self.address = RootSeqFlexRbanaMemorysignalgenSgleControlAddress(self._context)
        self.stop = RootSeqFlexRbanaMemorysignalgenSgleControlStop(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.memorysignalgen.sgle.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.memorysignalgen.sgle.control.regaddr', int(new_val))


class RootSeqFlexRbanaMemorysignalgenSgle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen.sgle'
        self.control = RootSeqFlexRbanaMemorysignalgenSgleControl(self._context)
        self.out = RootSeqFlexRbanaMemorysignalgenSgleOut(self._context)
        self.wvalue = RootSeqFlexRbanaMemorysignalgenSgleWvalue(self._context)
        self.increment = RootSeqFlexRbanaMemorysignalgenSgleIncrement(self._context)
        self.rvalue = RootSeqFlexRbanaMemorysignalgenSgleRvalue(self._context)
        self.samplecnt = RootSeqFlexRbanaMemorysignalgenSgleSamplecnt(self._context)
        self.sampleno = RootSeqFlexRbanaMemorysignalgenSgleSampleno(self._context)
        self.status = RootSeqFlexRbanaMemorysignalgenSgleStatus(self._context)


class RootSeqFlexRbanaMemorysignalgen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.memorysignalgen'
        self.sgle = RootSeqFlexRbanaMemorysignalgenSgle(self._context)


class RootSeqFlexRbanaComparatorComparator2Iircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.iircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.iircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.iircoef.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2Level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.level'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.level.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2Iiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.iiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.iiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.iiraddr.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2ControlComparatorinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.control.comparatorinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.comparatorinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.comparatorinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.comparatorinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.comparatorinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.comparatorinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.comparatorinput.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2ControlPolcomparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.control.polcomparator'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.polcomparator.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.polcomparator.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.polcomparator.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.polcomparator.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.polcomparator.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.polcomparator.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2ControlInputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.control.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.inputiir_vld.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2ControlFilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.control.filterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.filterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.filterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.filterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.filterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.filterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.filterena.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2.control'
        self.filterena = RootSeqFlexRbanaComparatorComparator2ControlFilterena(self._context)
        self.inputiir_vld = RootSeqFlexRbanaComparatorComparator2ControlInputiir_vld(self._context)
        self.polcomparator = RootSeqFlexRbanaComparatorComparator2ControlPolcomparator(self._context)
        self.comparatorinput = RootSeqFlexRbanaComparatorComparator2ControlComparatorinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator2.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator2.control.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator2'
        self.control = RootSeqFlexRbanaComparatorComparator2Control(self._context)
        self.iiraddr = RootSeqFlexRbanaComparatorComparator2Iiraddr(self._context)
        self.level = RootSeqFlexRbanaComparatorComparator2Level(self._context)
        self.iircoef = RootSeqFlexRbanaComparatorComparator2Iircoef(self._context)


class RootSeqFlexRbanaComparatorComparator1Iircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.iircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.iircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.iircoef.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1Level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.level'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.level.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1Iiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.iiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.iiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.iiraddr.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1ControlComparatorinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.control.comparatorinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.comparatorinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.comparatorinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.comparatorinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.comparatorinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.comparatorinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.comparatorinput.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1ControlPolcomparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.control.polcomparator'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.polcomparator.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.polcomparator.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.polcomparator.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.polcomparator.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.polcomparator.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.polcomparator.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1ControlInputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.control.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.inputiir_vld.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1ControlFilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.control.filterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.filterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.filterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.filterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.filterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.filterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.filterena.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1.control'
        self.filterena = RootSeqFlexRbanaComparatorComparator1ControlFilterena(self._context)
        self.inputiir_vld = RootSeqFlexRbanaComparatorComparator1ControlInputiir_vld(self._context)
        self.polcomparator = RootSeqFlexRbanaComparatorComparator1ControlPolcomparator(self._context)
        self.comparatorinput = RootSeqFlexRbanaComparatorComparator1ControlComparatorinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator1.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator1.control.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator1'
        self.control = RootSeqFlexRbanaComparatorComparator1Control(self._context)
        self.iiraddr = RootSeqFlexRbanaComparatorComparator1Iiraddr(self._context)
        self.level = RootSeqFlexRbanaComparatorComparator1Level(self._context)
        self.iircoef = RootSeqFlexRbanaComparatorComparator1Iircoef(self._context)


class RootSeqFlexRbanaComparatorComparator3Iircoef(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.iircoef'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.iircoef.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.iircoef.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3Level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.level'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.level.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.level.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3Iiraddr(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.iiraddr'

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.iiraddr.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.iiraddr.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3ControlComparatorinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.control.comparatorinput'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.comparatorinput.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.comparatorinput.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.comparatorinput.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.comparatorinput.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.comparatorinput.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.comparatorinput.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3ControlPolcomparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.control.polcomparator'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.polcomparator.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.polcomparator.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.polcomparator.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.polcomparator.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.polcomparator.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.polcomparator.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3ControlInputiir_vld(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.control.inputiir_vld'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.inputiir_vld.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.inputiir_vld.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.inputiir_vld.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.inputiir_vld.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.inputiir_vld.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.inputiir_vld.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3ControlFilterena(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.control.filterena'

    @property
    def lsb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.filterena.lsb'))

    @lsb.setter
    def lsb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.filterena.lsb', int(new_val))

    @property
    def msb(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.filterena.msb'))

    @msb.setter
    def msb(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.filterena.msb', int(new_val))

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.filterena.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.filterena.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3Control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3.control'
        self.filterena = RootSeqFlexRbanaComparatorComparator3ControlFilterena(self._context)
        self.inputiir_vld = RootSeqFlexRbanaComparatorComparator3ControlInputiir_vld(self._context)
        self.polcomparator = RootSeqFlexRbanaComparatorComparator3ControlPolcomparator(self._context)
        self.comparatorinput = RootSeqFlexRbanaComparatorComparator3ControlComparatorinput(self._context)

    @property
    def regaddr(self) -> int:
        return int(self._context.get('root.seq.flex.rbana.comparator.comparator3.control.regaddr'))

    @regaddr.setter
    def regaddr(self, new_val:int):
        self._context.set('root.seq.flex.rbana.comparator.comparator3.control.regaddr', int(new_val))


class RootSeqFlexRbanaComparatorComparator3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator.comparator3'
        self.control = RootSeqFlexRbanaComparatorComparator3Control(self._context)
        self.iiraddr = RootSeqFlexRbanaComparatorComparator3Iiraddr(self._context)
        self.level = RootSeqFlexRbanaComparatorComparator3Level(self._context)
        self.iircoef = RootSeqFlexRbanaComparatorComparator3Iircoef(self._context)


class RootSeqFlexRbanaComparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana.comparator'
        self.comparator3 = RootSeqFlexRbanaComparatorComparator3(self._context)
        self.comparator1 = RootSeqFlexRbanaComparatorComparator1(self._context)
        self.comparator2 = RootSeqFlexRbanaComparatorComparator2(self._context)


class RootSeqFlexRbana(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex.rbana'
        self.comparator = RootSeqFlexRbanaComparator(self._context)
        self.memorysignalgen = RootSeqFlexRbanaMemorysignalgen(self._context)
        self.datacapture = RootSeqFlexRbanaDatacapture(self._context)
        self.dpointfltr = RootSeqFlexRbanaDpointfltr(self._context)
        self.timer = RootSeqFlexRbanaTimer(self._context)
        self.datasampler = RootSeqFlexRbanaDatasampler(self._context)
        self.regaddr = RootSeqFlexRbanaRegaddr(self._context)
        self.pid = RootSeqFlexRbanaPid(self._context)
        self.seq = RootSeqFlexRbanaSeq(self._context)
        self.gpi = RootSeqFlexRbanaGpi(self._context)
        self.analyzercommon = RootSeqFlexRbanaAnalyzercommon(self._context)
        self.analyzer = RootSeqFlexRbanaAnalyzer(self._context)
        self.zctrlex = RootSeqFlexRbanaZctrlex(self._context)
        self.rampgen = RootSeqFlexRbanaRampgen(self._context)
        self.userio = RootSeqFlexRbanaUserio(self._context)
        self.outfast = RootSeqFlexRbanaOutfast(self._context)
        self.interna = RootSeqFlexRbanaInterna(self._context)
        self.outhirescommon = RootSeqFlexRbanaOuthirescommon(self._context)
        self.infast = RootSeqFlexRbanaInfast(self._context)
        self.inhirescommon = RootSeqFlexRbanaInhirescommon(self._context)
        self.outhires = RootSeqFlexRbanaOuthires(self._context)
        self.outfastcommon = RootSeqFlexRbanaOutfastcommon(self._context)
        self.inhires = RootSeqFlexRbanaInhires(self._context)
        self.infastcommon = RootSeqFlexRbanaInfastcommon(self._context)
        self.inchannelsdigi = RootSeqFlexRbanaInchannelsdigi(self._context)
        self.eventmgr = RootSeqFlexRbanaEventmgr(self._context)


class RootSeqFlex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq.flex'
        self.rbana = RootSeqFlexRbana(self._context)


class RootSeq(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.seq'
        self.flex = RootSeqFlex(self._context)
        self.cx = RootSeqCx(self._context)


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

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

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

    def select_main(self, *args) -> Any:
        return self._context.call('root.session.select_main', *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))

    @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))


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

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

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

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

    def list_table_tables(self, *args) -> Any:
        return self._context.call('root.util.list_table_tables', *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 make_property(self, *args) -> Any:
        return self._context.call('root.util.make_property', *args)

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

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

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

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


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 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))

    @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 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))

    @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))

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


class RootLuDirectmotorcontrolInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Busy'


class RootLuDirectmotorcontrolInstanceAttributeMoveadjust(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.MoveAdjust.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeAxismaxspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisMaxSpeed.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeAxisstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.AxisStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisStatus.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeTransactionmoverelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveRelative.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeAxislimitstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLimitStatus.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeTransactionmovedestination(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.TransactionMoveDestination.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeLayoutstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.LayoutStatus.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeCurrentlayout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentLayout.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeCurrentaxis(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.CurrentAxis.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeAxisposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.AxisPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisPosition.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeAxisspeedfactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisSpeedFactor.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttributeAxislastreferencemovedistance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Attribute.AxisLastReferenceMoveDistance.SetVectorString', *args)


class RootLuDirectmotorcontrolInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Attribute'
        self.AxisLastReferenceMoveDistance = RootLuDirectmotorcontrolInstanceAttributeAxislastreferencemovedistance(self._context)
        self.AxisSpeedFactor = RootLuDirectmotorcontrolInstanceAttributeAxisspeedfactor(self._context)
        self.AxisPosition = RootLuDirectmotorcontrolInstanceAttributeAxisposition(self._context)
        self.CurrentAxis = RootLuDirectmotorcontrolInstanceAttributeCurrentaxis(self._context)
        self.CurrentLayout = RootLuDirectmotorcontrolInstanceAttributeCurrentlayout(self._context)
        self.LayoutStatus = RootLuDirectmotorcontrolInstanceAttributeLayoutstatus(self._context)
        self.TransactionMoveDestination = RootLuDirectmotorcontrolInstanceAttributeTransactionmovedestination(self._context)
        self.AxisLimitStatus = RootLuDirectmotorcontrolInstanceAttributeAxislimitstatus(self._context)
        self.TransactionMoveRelative = RootLuDirectmotorcontrolInstanceAttributeTransactionmoverelative(self._context)
        self.AxisStatus = RootLuDirectmotorcontrolInstanceAttributeAxisstatus(self._context)
        self.AxisMaxSpeed = RootLuDirectmotorcontrolInstanceAttributeAxismaxspeed(self._context)
        self.MoveAdjust = RootLuDirectmotorcontrolInstanceAttributeMoveadjust(self._context)


class RootLuDirectmotorcontrolInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance.Trigger'

    def AddTransactionMove(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Trigger.AddTransactionMove', *args)

    def SearchReference(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Trigger.SearchReference', *args)

    def CommitTransaction(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Trigger.CommitTransaction', *args)

    def ResetTransaction(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Trigger.ResetTransaction', *args)

    def PositionZeroAxis(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Trigger.PositionZeroAxis', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.DirectMotorControl.Instance.Trigger.UserAbort', *args)


class RootLuDirectmotorcontrolInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl.Instance'
        self.Trigger = RootLuDirectmotorcontrolInstanceTrigger(self._context)
        self.Attribute = RootLuDirectmotorcontrolInstanceAttribute(self._context)
        self.Busy = RootLuDirectmotorcontrolInstanceBusy(self._context)


class RootLuDirectmotorcontrol(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DirectMotorControl'
        self.Instance = RootLuDirectmotorcontrolInstance(self._context)


class RootLuEventmanagerInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Busy'

    def IsBusy(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Busy.IsBusy', *args)


class RootLuEventmanagerInstanceAttributeEventvectorsnapshot(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.EventVectorSnapshot'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVectorSnapshot.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeObjectidle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.ObjectIdle'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectIdle.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeStartmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.StartMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StartMask.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeStopmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.StopMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopMask.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeAndmask0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.ANDMask0'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ANDMask0.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeStopeventmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.StopEventMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.StopEventMask.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeObjectqueuesize(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.ObjectQueueSize'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.ObjectQueueSize.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeAborteventmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.AbortEventMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.AbortEventMask.SetVectorString', *args)


class RootLuEventmanagerInstanceAttributeEventvector(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute.EventVector'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Attribute.EventVector.SetVectorString', *args)


class RootLuEventmanagerInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Attribute'
        self.EventVector = RootLuEventmanagerInstanceAttributeEventvector(self._context)
        self.AbortEventMask = RootLuEventmanagerInstanceAttributeAborteventmask(self._context)
        self.ObjectQueueSize = RootLuEventmanagerInstanceAttributeObjectqueuesize(self._context)
        self.StopEventMask = RootLuEventmanagerInstanceAttributeStopeventmask(self._context)
        self.ANDMask0 = RootLuEventmanagerInstanceAttributeAndmask0(self._context)
        self.StopMask = RootLuEventmanagerInstanceAttributeStopmask(self._context)
        self.StartMask = RootLuEventmanagerInstanceAttributeStartmask(self._context)
        self.ObjectIdle = RootLuEventmanagerInstanceAttributeObjectidle(self._context)
        self.EventVectorSnapshot = RootLuEventmanagerInstanceAttributeEventvectorsnapshot(self._context)


class RootLuEventmanagerInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Trigger.Start', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Trigger.Stop', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Trigger.UserAbort', *args)

    def SoftEvent0(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Trigger.SoftEvent0', *args)

    def SoftEvent1(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Trigger.SoftEvent1', *args)

    def SoftEvent2(self, *args) -> Any:
        return self._context.call('root.lu.EventManager.Instance.Trigger.SoftEvent2', *args)


class RootLuEventmanagerInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager.Instance'
        self.Trigger = RootLuEventmanagerInstanceTrigger(self._context)
        self.Attribute = RootLuEventmanagerInstanceAttribute(self._context)
        self.Busy = RootLuEventmanagerInstanceBusy(self._context)


class RootLuEventmanager(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.EventManager'
        self.Instance = RootLuEventmanagerInstance(self._context)


class RootLuAutoalignmentInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Busy'


class RootLuAutoalignmentInstanceAttributeAlignstate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.AlignState'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.AlignState.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttributePteopticalcentery(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterY.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttributeComponentstate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.ComponentState'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ComponentState.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttributeReadoutopticalcenterx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterX.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttributePteopticalcenterx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.PTEOpticalCenterX.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttributeCurrentopticcomponent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.CurrentOpticComponent.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttributeSearchalgorithm(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.SearchAlgorithm.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttributeReadoutopticalcentery(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Attribute.ReadoutOpticalCenterY.SetVectorString', *args)


class RootLuAutoalignmentInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Attribute'
        self.ReadoutOpticalCenterY = RootLuAutoalignmentInstanceAttributeReadoutopticalcentery(self._context)
        self.SearchAlgorithm = RootLuAutoalignmentInstanceAttributeSearchalgorithm(self._context)
        self.CurrentOpticComponent = RootLuAutoalignmentInstanceAttributeCurrentopticcomponent(self._context)
        self.PTEOpticalCenterX = RootLuAutoalignmentInstanceAttributePteopticalcenterx(self._context)
        self.ReadoutOpticalCenterX = RootLuAutoalignmentInstanceAttributeReadoutopticalcenterx(self._context)
        self.ComponentState = RootLuAutoalignmentInstanceAttributeComponentstate(self._context)
        self.PTEOpticalCenterY = RootLuAutoalignmentInstanceAttributePteopticalcentery(self._context)
        self.AlignState = RootLuAutoalignmentInstanceAttributeAlignstate(self._context)


class RootLuAutoalignmentInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance.Trigger'

    def StartMoveToOpticalCenter(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Trigger.StartMoveToOpticalCenter', *args)

    def StartSearchAlgorithm(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Trigger.StartSearchAlgorithm', *args)

    def StartOptimization(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Trigger.StartOptimization', *args)

    def StartAlign(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Trigger.StartAlign', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.AutoAlignment.Instance.Trigger.UserAbort', *args)


class RootLuAutoalignmentInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment.Instance'
        self.Trigger = RootLuAutoalignmentInstanceTrigger(self._context)
        self.Attribute = RootLuAutoalignmentInstanceAttribute(self._context)
        self.Busy = RootLuAutoalignmentInstanceBusy(self._context)


class RootLuAutoalignment(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AutoAlignment'
        self.Instance = RootLuAutoalignmentInstance(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 RootLuIsostageInstanceAttributeIsconnected(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Isostage.Instance.Attribute.IsConnected'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsConnected.SetVectorString', *args)


class RootLuIsostageInstanceAttributeOverloadsensitivity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Isostage.Instance.Attribute.OverloadSensitivity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.OverloadSensitivity.SetVectorString', *args)


class RootLuIsostageInstanceAttributeIsolationmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Isostage.Instance.Attribute.IsolationMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.IsolationMode.SetVectorString', *args)


class RootLuIsostageInstanceAttributeEventcounter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Isostage.Instance.Attribute.EventCounter'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Attribute.EventCounter.SetVectorString', *args)


class RootLuIsostageInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Isostage.Instance.Attribute'
        self.EventCounter = RootLuIsostageInstanceAttributeEventcounter(self._context)
        self.IsolationMode = RootLuIsostageInstanceAttributeIsolationmode(self._context)
        self.OverloadSensitivity = RootLuIsostageInstanceAttributeOverloadsensitivity(self._context)
        self.IsConnected = RootLuIsostageInstanceAttributeIsconnected(self._context)


class RootLuIsostageInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Isostage.Instance.Trigger'

    def UpdateSettings(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Trigger.UpdateSettings', *args)

    def TestConnection(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Trigger.TestConnection', *args)

    def ClearEventCounter(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Trigger.ClearEventCounter', *args)

    def SetupEventCounter(self, *args) -> Any:
        return self._context.call('root.lu.Isostage.Instance.Trigger.SetupEventCounter', *args)


class RootLuIsostageInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Isostage.Instance'
        self.Trigger = RootLuIsostageInstanceTrigger(self._context)
        self.Attribute = RootLuIsostageInstanceAttribute(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 RootLuLithoInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Busy'


class RootLuLithoInstanceAttributeMovezpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.MoveZPos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.MoveZPos.SetVectorString', *args)


class RootLuLithoInstanceAttributeXymovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.XYMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.XYMoveSpeed.SetVectorString', *args)


class RootLuLithoInstanceAttributeModrelvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.ModRelValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ModRelValue.SetVectorString', *args)


class RootLuLithoInstanceAttributeZmovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.ZMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.ZMoveSpeed.SetVectorString', *args)


class RootLuLithoInstanceAttributeAbsolutexpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.AbsoluteXPos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteXPos.SetVectorString', *args)


class RootLuLithoInstanceAttributeAbsoluteypos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.AbsoluteYPos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.AbsoluteYPos.SetVectorString', *args)


class RootLuLithoInstanceAttributeOpmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.OpMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.OpMode.SetVectorString', *args)


class RootLuLithoInstanceAttributePausetime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute.PauseTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Attribute.PauseTime.SetVectorString', *args)


class RootLuLithoInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Attribute'
        self.PauseTime = RootLuLithoInstanceAttributePausetime(self._context)
        self.OpMode = RootLuLithoInstanceAttributeOpmode(self._context)
        self.AbsoluteYPos = RootLuLithoInstanceAttributeAbsoluteypos(self._context)
        self.AbsoluteXPos = RootLuLithoInstanceAttributeAbsolutexpos(self._context)
        self.ZMoveSpeed = RootLuLithoInstanceAttributeZmovespeed(self._context)
        self.ModRelValue = RootLuLithoInstanceAttributeModrelvalue(self._context)
        self.XYMoveSpeed = RootLuLithoInstanceAttributeXymovespeed(self._context)
        self.MoveZPos = RootLuLithoInstanceAttributeMovezpos(self._context)


class RootLuLithoInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance.Trigger'

    def MoveToAbsXYPos(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.MoveToAbsXYPos', *args)

    def FirstCmdItem(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.FirstCmdItem', *args)

    def NextCmdItem(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.NextCmdItem', *args)

    def MakePause(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.MakePause', *args)

    def MoveToZ(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.MoveToZ', *args)

    def EndSequence(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.EndSequence', *args)

    def StartSequence(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.StartSequence', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.Litho.Instance.Trigger.UserAbort', *args)


class RootLuLithoInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Litho.Instance'
        self.Trigger = RootLuLithoInstanceTrigger(self._context)
        self.Attribute = RootLuLithoInstanceAttribute(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 RootLuAnaloghiresinPositionzBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Busy'


class RootLuAnaloghiresinPositionzAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionZ.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinPositionzAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinPositionzAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinPositionzAttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinPositionzAttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinPositionzAttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinPositionzAttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinPositionzAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinPositionzAttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinPositionzAttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinPositionzAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinPositionzAttributeCaliboffset(self._context)


class RootLuAnaloghiresinPositionzTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ.Trigger'


class RootLuAnaloghiresinPositionz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionZ'
        self.Trigger = RootLuAnaloghiresinPositionzTrigger(self._context)
        self.Attribute = RootLuAnaloghiresinPositionzAttribute(self._context)
        self.Busy = RootLuAnaloghiresinPositionzBusy(self._context)


class RootLuAnaloghiresinUser2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Busy'


class RootLuAnaloghiresinUser2AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinUser2AttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User2.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinUser2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinUser2AttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinUser2AttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinUser2AttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinUser2AttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinUser2AttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinUser2AttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinUser2AttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinUser2AttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinUser2AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinUser2AttributeCaliboffset(self._context)


class RootLuAnaloghiresinUser2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2.Trigger'


class RootLuAnaloghiresinUser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User2'
        self.Trigger = RootLuAnaloghiresinUser2Trigger(self._context)
        self.Attribute = RootLuAnaloghiresinUser2Attribute(self._context)
        self.Busy = RootLuAnaloghiresinUser2Busy(self._context)


class RootLuAnaloghiresinUser3Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Busy'


class RootLuAnaloghiresinUser3AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinUser3AttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User3.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinUser3Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinUser3AttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinUser3AttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinUser3AttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinUser3AttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinUser3AttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinUser3AttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinUser3AttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinUser3AttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinUser3AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinUser3AttributeCaliboffset(self._context)


class RootLuAnaloghiresinUser3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3.Trigger'


class RootLuAnaloghiresinUser3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User3'
        self.Trigger = RootLuAnaloghiresinUser3Trigger(self._context)
        self.Attribute = RootLuAnaloghiresinUser3Attribute(self._context)
        self.Busy = RootLuAnaloghiresinUser3Busy(self._context)


class RootLuAnaloghiresinIn6Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Busy'


class RootLuAnaloghiresinIn6AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinIn6AttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.In6.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinIn6Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinIn6AttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinIn6AttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinIn6AttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinIn6AttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinIn6AttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinIn6AttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinIn6AttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinIn6AttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinIn6AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinIn6AttributeCaliboffset(self._context)


class RootLuAnaloghiresinIn6Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6.Trigger'


class RootLuAnaloghiresinIn6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.In6'
        self.Trigger = RootLuAnaloghiresinIn6Trigger(self._context)
        self.Attribute = RootLuAnaloghiresinIn6Attribute(self._context)
        self.Busy = RootLuAnaloghiresinIn6Busy(self._context)


class RootLuAnaloghiresinPositionyBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Busy'


class RootLuAnaloghiresinPositionyAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionY.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinPositionyAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinPositionyAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinPositionyAttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinPositionyAttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinPositionyAttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinPositionyAttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinPositionyAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinPositionyAttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinPositionyAttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinPositionyAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinPositionyAttributeCaliboffset(self._context)


class RootLuAnaloghiresinPositionyTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY.Trigger'


class RootLuAnaloghiresinPositiony(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionY'
        self.Trigger = RootLuAnaloghiresinPositionyTrigger(self._context)
        self.Attribute = RootLuAnaloghiresinPositionyAttribute(self._context)
        self.Busy = RootLuAnaloghiresinPositionyBusy(self._context)


class RootLuAnaloghiresinUser4Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Busy'


class RootLuAnaloghiresinUser4AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinUser4AttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User4.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinUser4Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinUser4AttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinUser4AttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinUser4AttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinUser4AttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinUser4AttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinUser4AttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinUser4AttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinUser4AttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinUser4AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinUser4AttributeCaliboffset(self._context)


class RootLuAnaloghiresinUser4Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4.Trigger'


class RootLuAnaloghiresinUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User4'
        self.Trigger = RootLuAnaloghiresinUser4Trigger(self._context)
        self.Attribute = RootLuAnaloghiresinUser4Attribute(self._context)
        self.Busy = RootLuAnaloghiresinUser4Busy(self._context)


class RootLuAnaloghiresinDeflectionBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Busy'


class RootLuAnaloghiresinDeflectionAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinDeflectionAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinDeflectionAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinDeflectionAttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinDeflectionAttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinDeflectionAttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinDeflectionAttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinDeflectionAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinDeflectionAttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinDeflectionAttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinDeflectionAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinDeflectionAttributeCaliboffset(self._context)


class RootLuAnaloghiresinDeflectionTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection.Trigger'


class RootLuAnaloghiresinDeflection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Deflection'
        self.Trigger = RootLuAnaloghiresinDeflectionTrigger(self._context)
        self.Attribute = RootLuAnaloghiresinDeflectionAttribute(self._context)
        self.Busy = RootLuAnaloghiresinDeflectionBusy(self._context)


class RootLuAnaloghiresinLateralBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Busy'


class RootLuAnaloghiresinLateralAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.Lateral.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinLateralAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinLateralAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinLateralAttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinLateralAttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinLateralAttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinLateralAttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinLateralAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinLateralAttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinLateralAttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinLateralAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinLateralAttributeCaliboffset(self._context)


class RootLuAnaloghiresinLateralTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral.Trigger'


class RootLuAnaloghiresinLateral(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.Lateral'
        self.Trigger = RootLuAnaloghiresinLateralTrigger(self._context)
        self.Attribute = RootLuAnaloghiresinLateralAttribute(self._context)
        self.Busy = RootLuAnaloghiresinLateralBusy(self._context)


class RootLuAnaloghiresinPositionxBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Busy'


class RootLuAnaloghiresinPositionxAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.PositionX.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinPositionxAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinPositionxAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinPositionxAttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinPositionxAttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinPositionxAttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinPositionxAttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinPositionxAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinPositionxAttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinPositionxAttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinPositionxAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinPositionxAttributeCaliboffset(self._context)


class RootLuAnaloghiresinPositionxTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX.Trigger'


class RootLuAnaloghiresinPositionx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.PositionX'
        self.Trigger = RootLuAnaloghiresinPositionxTrigger(self._context)
        self.Attribute = RootLuAnaloghiresinPositionxAttribute(self._context)
        self.Busy = RootLuAnaloghiresinPositionxBusy(self._context)


class RootLuAnaloghiresinTipcurrentBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Busy'


class RootLuAnaloghiresinTipcurrentAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.TipCurrent.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinTipcurrentAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinTipcurrentAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinTipcurrentAttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinTipcurrentAttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinTipcurrentAttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinTipcurrentAttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinTipcurrentAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinTipcurrentAttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinTipcurrentAttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinTipcurrentAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinTipcurrentAttributeCaliboffset(self._context)


class RootLuAnaloghiresinTipcurrentTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent.Trigger'


class RootLuAnaloghiresinTipcurrent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.TipCurrent'
        self.Trigger = RootLuAnaloghiresinTipcurrentTrigger(self._context)
        self.Attribute = RootLuAnaloghiresinTipcurrentAttribute(self._context)
        self.Busy = RootLuAnaloghiresinTipcurrentBusy(self._context)


class RootLuAnaloghiresinUser1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Busy'


class RootLuAnaloghiresinUser1AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinUser1AttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.User1.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinUser1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinUser1AttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinUser1AttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinUser1AttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinUser1AttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinUser1AttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinUser1AttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinUser1AttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinUser1AttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinUser1AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinUser1AttributeCaliboffset(self._context)


class RootLuAnaloghiresinUser1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1.Trigger'


class RootLuAnaloghiresinUser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.User1'
        self.Trigger = RootLuAnaloghiresinUser1Trigger(self._context)
        self.Attribute = RootLuAnaloghiresinUser1Attribute(self._context)
        self.Busy = RootLuAnaloghiresinUser1Busy(self._context)


class RootLuAnaloghiresinDetectorsumBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Busy'


class RootLuAnaloghiresinDetectorsumAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeFiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.FilterMode.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResIn.DetectorSum.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnaloghiresinDetectorsumAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnaloghiresinDetectorsumAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnaloghiresinDetectorsumAttributeCalibgain(self._context)
        self.FilterMode = RootLuAnaloghiresinDetectorsumAttributeFiltermode(self._context)
        self.FilterNumber = RootLuAnaloghiresinDetectorsumAttributeFilternumber(self._context)
        self.CrossCouplingAxisID = RootLuAnaloghiresinDetectorsumAttributeCrosscouplingaxisid(self._context)
        self.CurrentInputValue = RootLuAnaloghiresinDetectorsumAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresinDetectorsumAttributeFiltercoeffvec(self._context)
        self.InputOffset = RootLuAnaloghiresinDetectorsumAttributeInputoffset(self._context)
        self.CalibPolarity = RootLuAnaloghiresinDetectorsumAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresinDetectorsumAttributeCaliboffset(self._context)


class RootLuAnaloghiresinDetectorsumTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum.Trigger'


class RootLuAnaloghiresinDetectorsum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn.DetectorSum'
        self.Trigger = RootLuAnaloghiresinDetectorsumTrigger(self._context)
        self.Attribute = RootLuAnaloghiresinDetectorsumAttribute(self._context)
        self.Busy = RootLuAnaloghiresinDetectorsumBusy(self._context)


class RootLuAnaloghiresin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResIn'
        self.DetectorSum = RootLuAnaloghiresinDetectorsum(self._context)
        self.User1 = RootLuAnaloghiresinUser1(self._context)
        self.TipCurrent = RootLuAnaloghiresinTipcurrent(self._context)
        self.PositionX = RootLuAnaloghiresinPositionx(self._context)
        self.Lateral = RootLuAnaloghiresinLateral(self._context)
        self.Deflection = RootLuAnaloghiresinDeflection(self._context)
        self.User4 = RootLuAnaloghiresinUser4(self._context)
        self.PositionY = RootLuAnaloghiresinPositiony(self._context)
        self.In6 = RootLuAnaloghiresinIn6(self._context)
        self.User3 = RootLuAnaloghiresinUser3(self._context)
        self.User2 = RootLuAnaloghiresinUser2(self._context)
        self.PositionZ = RootLuAnaloghiresinPositionz(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'

    def IsRunning(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Busy.IsRunning', *args)


class RootLuSequencerInstanceAttributeInstructionpointer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Sequencer.Instance.Attribute.InstructionPointer'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.InstructionPointer.SetVectorString', *args)


class RootLuSequencerInstanceAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Sequencer.Instance.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.Status.SetVectorString', *args)


class RootLuSequencerInstanceAttributeMemoryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Sequencer.Instance.Attribute.MemoryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Attribute.MemoryVec.SetVectorString', *args)


class RootLuSequencerInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Sequencer.Instance.Attribute'
        self.MemoryVec = RootLuSequencerInstanceAttributeMemoryvec(self._context)
        self.Status = RootLuSequencerInstanceAttributeStatus(self._context)
        self.InstructionPointer = RootLuSequencerInstanceAttributeInstructionpointer(self._context)


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, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Trigger.Start', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Trigger.Abort', *args)

    def Step(self, *args) -> Any:
        return self._context.call('root.lu.Sequencer.Instance.Trigger.Step', *args)


class RootLuSequencerInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Sequencer.Instance'
        self.Trigger = RootLuSequencerInstanceTrigger(self._context)
        self.Attribute = RootLuSequencerInstanceAttribute(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 RootLuSystemInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Busy'


class RootLuSystemInstanceAttributeMemoryavailable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.MemoryAvailable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryAvailable.SetVectorString', *args)


class RootLuSystemInstanceAttributeMotorselection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.MotorSelection'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorSelection.SetVectorString', *args)


class RootLuSystemInstanceAttributeOperatingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.OperatingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OperatingMode.SetVectorString', *args)


class RootLuSystemInstanceAttributeIdlepositionxymode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.IdlePositionXYMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionXYMode.SetVectorString', *args)


class RootLuSystemInstanceAttributeIdlepositionzmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.IdlePositionZMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZMode.SetVectorString', *args)


class RootLuSystemInstanceAttributeIdleexternalz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.IdleExternalZ'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZ.SetVectorString', *args)


class RootLuSystemInstanceAttributeMotormovespeedfactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.MotorMoveSpeedFactor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveSpeedFactor.SetVectorString', *args)


class RootLuSystemInstanceAttributeIdleexternalzmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.IdleExternalZMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdleExternalZMode.SetVectorString', *args)


class RootLuSystemInstanceAttributeMotormovedirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.MotorMoveDirection'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorMoveDirection.SetVectorString', *args)


class RootLuSystemInstanceAttributeSystemstate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.SystemState'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.SystemState.SetVectorString', *args)


class RootLuSystemInstanceAttributeMotorstepsize(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.MotorStepSize'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MotorStepSize.SetVectorString', *args)


class RootLuSystemInstanceAttributeHiresch5input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.HiResCh5Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh5Input.SetVectorString', *args)


class RootLuSystemInstanceAttributeIdlepositionz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.IdlePositionZ'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.IdlePositionZ.SetVectorString', *args)


class RootLuSystemInstanceAttributeMeasurementenvironment(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.MeasurementEnvironment'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MeasurementEnvironment.SetVectorString', *args)


class RootLuSystemInstanceAttributeZaxisctrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.ZAxisCtrlMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.ZAxisCtrlMode.SetVectorString', *args)


class RootLuSystemInstanceAttributeHiresch4input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.HiResCh4Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.HiResCh4Input.SetVectorString', *args)


class RootLuSystemInstanceAttributeMemoryblockavailable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.MemoryBlockAvailable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.MemoryBlockAvailable.SetVectorString', *args)


class RootLuSystemInstanceAttributeOpmodekpfmenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute.OpModeKPFMEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Attribute.OpModeKPFMEnabled.SetVectorString', *args)


class RootLuSystemInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Attribute'
        self.OpModeKPFMEnabled = RootLuSystemInstanceAttributeOpmodekpfmenabled(self._context)
        self.MemoryBlockAvailable = RootLuSystemInstanceAttributeMemoryblockavailable(self._context)
        self.HiResCh4Input = RootLuSystemInstanceAttributeHiresch4input(self._context)
        self.ZAxisCtrlMode = RootLuSystemInstanceAttributeZaxisctrlmode(self._context)
        self.MeasurementEnvironment = RootLuSystemInstanceAttributeMeasurementenvironment(self._context)
        self.IdlePositionZ = RootLuSystemInstanceAttributeIdlepositionz(self._context)
        self.HiResCh5Input = RootLuSystemInstanceAttributeHiresch5input(self._context)
        self.MotorStepSize = RootLuSystemInstanceAttributeMotorstepsize(self._context)
        self.SystemState = RootLuSystemInstanceAttributeSystemstate(self._context)
        self.MotorMoveDirection = RootLuSystemInstanceAttributeMotormovedirection(self._context)
        self.IdleExternalZMode = RootLuSystemInstanceAttributeIdleexternalzmode(self._context)
        self.MotorMoveSpeedFactor = RootLuSystemInstanceAttributeMotormovespeedfactor(self._context)
        self.IdleExternalZ = RootLuSystemInstanceAttributeIdleexternalz(self._context)
        self.IdlePositionZMode = RootLuSystemInstanceAttributeIdlepositionzmode(self._context)
        self.IdlePositionXYMode = RootLuSystemInstanceAttributeIdlepositionxymode(self._context)
        self.OperatingMode = RootLuSystemInstanceAttributeOperatingmode(self._context)
        self.MotorSelection = RootLuSystemInstanceAttributeMotorselection(self._context)
        self.MemoryAvailable = RootLuSystemInstanceAttributeMemoryavailable(self._context)


class RootLuSystemInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance.Trigger'

    def EntryUncal(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.EntryUncal', *args)

    def StartSystemStartup(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.StartSystemStartup', *args)

    def EntryIdle(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.EntryIdle', *args)

    def EntryScan(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.EntryScan', *args)

    def EntryLitho(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.EntryLitho', *args)

    def DoForceMotorPosUpdate(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.DoForceMotorPosUpdate', *args)

    def MotorStep(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.MotorStep', *args)

    def EntrySpec(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.EntrySpec', *args)

    def OffsetXYZ(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.OffsetXYZ', *args)

    def MotorStop(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.MotorStop', *args)

    def MotorSetPosZero(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.MotorSetPosZero', *args)

    def ExitUncal(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.ExitUncal', *args)

    def MotorReferenceAndMoveBack(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.MotorReferenceAndMoveBack', *args)

    def MotorReference(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.MotorReference', *args)

    def MotorMove(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.MotorMove', *args)

    def LevelScanhead(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.LevelScanhead', *args)

    def ExitScan(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.ExitScan', *args)

    def ExitSpec(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.ExitSpec', *args)

    def EntryApproach(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.EntryApproach', *args)

    def ExitMacroCmd(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.ExitMacroCmd', *args)

    def ExitApproach(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.ExitApproach', *args)

    def ExitIdle(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.ExitIdle', *args)

    def ExitLitho(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.ExitLitho', *args)

    def EntryMacroCmd(self, *args) -> Any:
        return self._context.call('root.lu.System.Instance.Trigger.EntryMacroCmd', *args)


class RootLuSystemInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.System.Instance'
        self.Trigger = RootLuSystemInstanceTrigger(self._context)
        self.Attribute = RootLuSystemInstanceAttribute(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 RootLuTimerProc0Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Busy'

    def IsBusy(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Busy.IsBusy', *args)


class RootLuTimerProc0AttributeCounterinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Attribute.CounterInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterInput.SetVectorString', *args)


class RootLuTimerProc0AttributeCurrenttimer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Attribute.CurrentTimer'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CurrentTimer.SetVectorString', *args)


class RootLuTimerProc0AttributeMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Attribute.Mode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.Mode.SetVectorString', *args)


class RootLuTimerProc0AttributeCountermax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Attribute.CounterMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterMax.SetVectorString', *args)


class RootLuTimerProc0AttributeCountervalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Attribute.CounterValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.CounterValue.SetVectorString', *args)


class RootLuTimerProc0AttributeDelaytime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Attribute.DelayTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Attribute.DelayTime.SetVectorString', *args)


class RootLuTimerProc0Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0.Attribute'
        self.DelayTime = RootLuTimerProc0AttributeDelaytime(self._context)
        self.CounterValue = RootLuTimerProc0AttributeCountervalue(self._context)
        self.CounterMax = RootLuTimerProc0AttributeCountermax(self._context)
        self.Mode = RootLuTimerProc0AttributeMode(self._context)
        self.CurrentTimer = RootLuTimerProc0AttributeCurrenttimer(self._context)
        self.CounterInput = RootLuTimerProc0AttributeCounterinput(self._context)


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, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Trigger.Start', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Proc0.Trigger.Stop', *args)


class RootLuTimerProc0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Proc0'
        self.Trigger = RootLuTimerProc0Trigger(self._context)
        self.Attribute = RootLuTimerProc0Attribute(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'

    def IsBusy(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Busy.IsBusy', *args)


class RootLuTimerDbg1AttributeCounterinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1.Attribute.CounterInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterInput.SetVectorString', *args)


class RootLuTimerDbg1AttributeCurrenttimer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1.Attribute.CurrentTimer'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CurrentTimer.SetVectorString', *args)


class RootLuTimerDbg1AttributeMode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1.Attribute.Mode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.Mode.SetVectorString', *args)


class RootLuTimerDbg1AttributeCountermax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1.Attribute.CounterMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterMax.SetVectorString', *args)


class RootLuTimerDbg1AttributeCountervalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1.Attribute.CounterValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.CounterValue.SetVectorString', *args)


class RootLuTimerDbg1AttributeDelaytime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1.Attribute.DelayTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Attribute.DelayTime.SetVectorString', *args)


class RootLuTimerDbg1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1.Attribute'
        self.DelayTime = RootLuTimerDbg1AttributeDelaytime(self._context)
        self.CounterValue = RootLuTimerDbg1AttributeCountervalue(self._context)
        self.CounterMax = RootLuTimerDbg1AttributeCountermax(self._context)
        self.Mode = RootLuTimerDbg1AttributeMode(self._context)
        self.CurrentTimer = RootLuTimerDbg1AttributeCurrenttimer(self._context)
        self.CounterInput = RootLuTimerDbg1AttributeCounterinput(self._context)


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, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Trigger.Start', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.Timer.Dbg1.Trigger.Stop', *args)


class RootLuTimerDbg1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Timer.Dbg1'
        self.Trigger = RootLuTimerDbg1Trigger(self._context)
        self.Attribute = RootLuTimerDbg1Attribute(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 RootLuAnalogfastinDeflectionBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Busy'


class RootLuAnalogfastinDeflectionAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttributeInputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.InputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputGain.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Deflection.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnalogfastinDeflectionAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnalogfastinDeflectionAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnalogfastinDeflectionAttributeCalibgain(self._context)
        self.CurrentInputValue = RootLuAnalogfastinDeflectionAttributeCurrentinputvalue(self._context)
        self.InputOffset = RootLuAnalogfastinDeflectionAttributeInputoffset(self._context)
        self.InputGain = RootLuAnalogfastinDeflectionAttributeInputgain(self._context)
        self.CrossCouplingAxisID = RootLuAnalogfastinDeflectionAttributeCrosscouplingaxisid(self._context)
        self.CalibPolarity = RootLuAnalogfastinDeflectionAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnalogfastinDeflectionAttributeCaliboffset(self._context)


class RootLuAnalogfastinDeflectionTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection.Trigger'


class RootLuAnalogfastinDeflection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Deflection'
        self.Trigger = RootLuAnalogfastinDeflectionTrigger(self._context)
        self.Attribute = RootLuAnalogfastinDeflectionAttribute(self._context)
        self.Busy = RootLuAnalogfastinDeflectionBusy(self._context)


class RootLuAnalogfastinCh2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Busy'


class RootLuAnalogfastinCh2AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnalogfastinCh2AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnalogfastinCh2AttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnalogfastinCh2AttributeInputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.InputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputGain.SetVectorString', *args)


class RootLuAnalogfastinCh2AttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnalogfastinCh2AttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnalogfastinCh2AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnalogfastinCh2AttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.Ch2.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnalogfastinCh2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnalogfastinCh2AttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnalogfastinCh2AttributeCalibgain(self._context)
        self.CurrentInputValue = RootLuAnalogfastinCh2AttributeCurrentinputvalue(self._context)
        self.InputOffset = RootLuAnalogfastinCh2AttributeInputoffset(self._context)
        self.InputGain = RootLuAnalogfastinCh2AttributeInputgain(self._context)
        self.CrossCouplingAxisID = RootLuAnalogfastinCh2AttributeCrosscouplingaxisid(self._context)
        self.CalibPolarity = RootLuAnalogfastinCh2AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnalogfastinCh2AttributeCaliboffset(self._context)


class RootLuAnalogfastinCh2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2.Trigger'


class RootLuAnalogfastinCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.Ch2'
        self.Trigger = RootLuAnalogfastinCh2Trigger(self._context)
        self.Attribute = RootLuAnalogfastinCh2Attribute(self._context)
        self.Busy = RootLuAnalogfastinCh2Busy(self._context)


class RootLuAnalogfastinUserBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Busy'


class RootLuAnalogfastinUserAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnalogfastinUserAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnalogfastinUserAttributeCrosscouplingaxisid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisID.SetVectorString', *args)


class RootLuAnalogfastinUserAttributeInputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.InputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputGain.SetVectorString', *args)


class RootLuAnalogfastinUserAttributeInputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.InputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.InputOffset.SetVectorString', *args)


class RootLuAnalogfastinUserAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuAnalogfastinUserAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnalogfastinUserAttributeCrosscouplingaxiscoefficientvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastIn.User.Attribute.CrossCouplingAxisCoefficientVec.SetVectorString', *args)


class RootLuAnalogfastinUserAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Attribute'
        self.CrossCouplingAxisCoefficientVec = RootLuAnalogfastinUserAttributeCrosscouplingaxiscoefficientvec(self._context)
        self.CalibGain = RootLuAnalogfastinUserAttributeCalibgain(self._context)
        self.CurrentInputValue = RootLuAnalogfastinUserAttributeCurrentinputvalue(self._context)
        self.InputOffset = RootLuAnalogfastinUserAttributeInputoffset(self._context)
        self.InputGain = RootLuAnalogfastinUserAttributeInputgain(self._context)
        self.CrossCouplingAxisID = RootLuAnalogfastinUserAttributeCrosscouplingaxisid(self._context)
        self.CalibPolarity = RootLuAnalogfastinUserAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnalogfastinUserAttributeCaliboffset(self._context)


class RootLuAnalogfastinUserTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User.Trigger'


class RootLuAnalogfastinUser(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn.User'
        self.Trigger = RootLuAnalogfastinUserTrigger(self._context)
        self.Attribute = RootLuAnalogfastinUserAttribute(self._context)
        self.Busy = RootLuAnalogfastinUserBusy(self._context)


class RootLuAnalogfastin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastIn'
        self.User = RootLuAnalogfastinUser(self._context)
        self.Ch2 = RootLuAnalogfastinCh2(self._context)
        self.Deflection = RootLuAnalogfastinDeflection(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 RootLuScanInstanceAttributeContourenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.ContourEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourEnabled.SetVectorString', *args)


class RootLuScanInstanceAttributeScandirectionslowaxis(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ScanDirectionSlowAxis.SetVectorString', *args)


class RootLuScanInstanceAttributeSlowincrement(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SlowIncrement'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowIncrement.SetVectorString', *args)


class RootLuScanInstanceAttributeSlowpoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SlowPoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowPoints.SetVectorString', *args)


class RootLuScanInstanceAttributeZoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.ZOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZOffset.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscanforcemodulationamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitude.SetVectorString', *args)


class RootLuScanInstanceAttributeSlowrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SlowRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowRange.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscansndlockinexcitationamplitudeenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitudeEnabled.SetVectorString', *args)


class RootLuScanInstanceAttributeXymovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.XYMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XYMoveSpeed.SetVectorString', *args)


class RootLuScanInstanceAttributeXrotation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.XRotation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XRotation.SetVectorString', *args)


class RootLuScanInstanceAttributeTimeperline(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.TimePerLine'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.TimePerLine.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscandynamicamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitude.SetVectorString', *args)


class RootLuScanInstanceAttributeGenerator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.Generator'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.Generator.SetVectorString', *args)


class RootLuScanInstanceAttributeMovemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.MoveMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.MoveMode.SetVectorString', *args)


class RootLuScanInstanceAttributeAutoreadjustprobeenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.AutoReadjustProbeEnabled.SetVectorString', *args)


class RootLuScanInstanceAttributeFastrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.FastRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastRange.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscanenabledarkmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableDarkMode.SetVectorString', *args)


class RootLuScanInstanceAttributeYrotation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.YRotation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YRotation.SetVectorString', *args)


class RootLuScanInstanceAttributeZrotation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.ZRotation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZRotation.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscanenablekpfm(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanEnableKPFM'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanEnableKPFM.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscanforcemodulationamplitudeenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanForceModulationAmplitudeEnabled.SetVectorString', *args)


class RootLuScanInstanceAttributeLinearizationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.LinearizationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LinearizationEnable.SetVectorString', *args)


class RootLuScanInstanceAttributeLinezoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.LineZOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineZOffset.SetVectorString', *args)


class RootLuScanInstanceAttributeFastpoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.FastPoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FastPoints.SetVectorString', *args)


class RootLuScanInstanceAttributeFirstlinerepetition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.FirstLineRepetition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.FirstLineRepetition.SetVectorString', *args)


class RootLuScanInstanceAttributeZmovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.ZMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ZMoveSpeed.SetVectorString', *args)


class RootLuScanInstanceAttributeReadjustliftheight(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.ReadjustLiftHeight'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ReadjustLiftHeight.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscansndlockinexcitationamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanSndLockInExcitationAmplitude.SetVectorString', *args)


class RootLuScanInstanceAttributeSndscandynamicamplitudeenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SndScanDynamicAmplitudeEnabled.SetVectorString', *args)


class RootLuScanInstanceAttributeSlowaxismovemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.SlowAxisMoveMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.SlowAxisMoveMode.SetVectorString', *args)


class RootLuScanInstanceAttributeLinescanning(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.LineScanning'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.LineScanning.SetVectorString', *args)


class RootLuScanInstanceAttributeXoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.XOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.XOffset.SetVectorString', *args)


class RootLuScanInstanceAttributeYoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.YOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.YOffset.SetVectorString', *args)


class RootLuScanInstanceAttributeBackwardfastpoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.BackwardFastPoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.BackwardFastPoints.SetVectorString', *args)


class RootLuScanInstanceAttributeOverscanpoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.OverscanPoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.OverscanPoints.SetVectorString', *args)


class RootLuScanInstanceAttributeContourdatachannel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute.ContourDataChannel'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Attribute.ContourDataChannel.SetVectorString', *args)


class RootLuScanInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Attribute'
        self.ContourDataChannel = RootLuScanInstanceAttributeContourdatachannel(self._context)
        self.OverscanPoints = RootLuScanInstanceAttributeOverscanpoints(self._context)
        self.BackwardFastPoints = RootLuScanInstanceAttributeBackwardfastpoints(self._context)
        self.YOffset = RootLuScanInstanceAttributeYoffset(self._context)
        self.XOffset = RootLuScanInstanceAttributeXoffset(self._context)
        self.LineScanning = RootLuScanInstanceAttributeLinescanning(self._context)
        self.SlowAxisMoveMode = RootLuScanInstanceAttributeSlowaxismovemode(self._context)
        self.SndScanDynamicAmplitudeEnabled = RootLuScanInstanceAttributeSndscandynamicamplitudeenabled(self._context)
        self.SndScanSndLockInExcitationAmplitude = RootLuScanInstanceAttributeSndscansndlockinexcitationamplitude(self._context)
        self.ReadjustLiftHeight = RootLuScanInstanceAttributeReadjustliftheight(self._context)
        self.ZMoveSpeed = RootLuScanInstanceAttributeZmovespeed(self._context)
        self.FirstLineRepetition = RootLuScanInstanceAttributeFirstlinerepetition(self._context)
        self.FastPoints = RootLuScanInstanceAttributeFastpoints(self._context)
        self.LineZOffset = RootLuScanInstanceAttributeLinezoffset(self._context)
        self.LinearizationEnable = RootLuScanInstanceAttributeLinearizationenable(self._context)
        self.SndScanForceModulationAmplitudeEnabled = RootLuScanInstanceAttributeSndscanforcemodulationamplitudeenabled(self._context)
        self.SndScanEnableKPFM = RootLuScanInstanceAttributeSndscanenablekpfm(self._context)
        self.ZRotation = RootLuScanInstanceAttributeZrotation(self._context)
        self.YRotation = RootLuScanInstanceAttributeYrotation(self._context)
        self.SndScanEnableDarkMode = RootLuScanInstanceAttributeSndscanenabledarkmode(self._context)
        self.FastRange = RootLuScanInstanceAttributeFastrange(self._context)
        self.AutoReadjustProbeEnabled = RootLuScanInstanceAttributeAutoreadjustprobeenabled(self._context)
        self.MoveMode = RootLuScanInstanceAttributeMovemode(self._context)
        self.Generator = RootLuScanInstanceAttributeGenerator(self._context)
        self.SndScanDynamicAmplitude = RootLuScanInstanceAttributeSndscandynamicamplitude(self._context)
        self.TimePerLine = RootLuScanInstanceAttributeTimeperline(self._context)
        self.XRotation = RootLuScanInstanceAttributeXrotation(self._context)
        self.XYMoveSpeed = RootLuScanInstanceAttributeXymovespeed(self._context)
        self.SndScanSndLockInExcitationAmplitudeEnabled = RootLuScanInstanceAttributeSndscansndlockinexcitationamplitudeenabled(self._context)
        self.SlowRange = RootLuScanInstanceAttributeSlowrange(self._context)
        self.SndScanForceModulationAmplitude = RootLuScanInstanceAttributeSndscanforcemodulationamplitude(self._context)
        self.ZOffset = RootLuScanInstanceAttributeZoffset(self._context)
        self.SlowPoints = RootLuScanInstanceAttributeSlowpoints(self._context)
        self.SlowIncrement = RootLuScanInstanceAttributeSlowincrement(self._context)
        self.ScanDirectionSlowAxis = RootLuScanInstanceAttributeScandirectionslowaxis(self._context)
        self.ContourEnabled = RootLuScanInstanceAttributeContourenabled(self._context)


class RootLuScanInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance.Trigger'

    def StartDoFrame(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Trigger.StartDoFrame', *args)

    def StartMoveToStart(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Trigger.StartMoveToStart', *args)

    def StartMoveToStartAndDoFrameQuick(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Trigger.StartMoveToStartAndDoFrameQuick', *args)

    def StartMoveToStartAndDoFrame(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Trigger.StartMoveToStartAndDoFrame', *args)

    def OffsetXYZ(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Trigger.OffsetXYZ', *args)

    def DoSetXYSensorDataAcquisition(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Trigger.DoSetXYSensorDataAcquisition', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.Scan.Instance.Trigger.UserAbort', *args)


class RootLuScanInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scan.Instance'
        self.Trigger = RootLuScanInstanceTrigger(self._context)
        self.Attribute = RootLuScanInstanceAttribute(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 RootLuZcontrollerexInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Busy'


class RootLuZcontrollerexInstanceAttributeClosedloopigain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopIGain.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentpidcommandvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPIDCommandValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentPhase'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentPhase.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentstatusflags(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentStatusFlags.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeEnablememorysignalgendrive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenDrive.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeBaseworkmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseWorkMode.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeInputcomparemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.InputCompareMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareMode.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeInputcomparevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.InputCompareValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.InputCompareValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeDdcfiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterCoeffVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeSetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.SetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPoint.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeMinzvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.MinZValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MinZValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeOuputmodulationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OuputModulationEnable.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeOutputcomparemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareMode.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasemovemodevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveModeVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeOutputcomparevalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.OutputCompareValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasemovespeedvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveSpeedVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhaseinitphasecount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseInitPhaseCount.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentinputfilteredvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputFilteredValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeMaxzvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.MaxZValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeBaselinepos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.BaseLinePos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.BaseLinePos.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentinputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentInputValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasemovetimevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveTimeVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeEnablememorysignalgenposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.EnableMemorySignalGenPosition.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasemovevaluevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveValueVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentsumvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentSumValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhaserealendposvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseRealEndPosVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeDdcfilterrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterRate.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrenterrorvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentErrorValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasecount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseCount'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseCount.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeDifferentialgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.DifferentialGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DifferentialGain.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhaseworkmodevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseWorkModeVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeNumberofpidgainsets(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.NumberOfPIDGainSets.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeProportionalgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.ProportionalGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ProportionalGain.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCtrlinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CtrlInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CtrlInput.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeIntegralgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.IntegralGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.IntegralGain.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeDdcfilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.DdcFilterNumber.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentoutputchannel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentOutputChannel.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeFeedbackpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.FeedbackPolarity.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeSetpointmodulationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.SetPointModulationEnable.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeTargetoutputchannel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.TargetOutputChannel.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasepausetimevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhasePauseTimeVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeZcontrolleradjusttimedout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ZControllerAdjustTimedOut.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentlimitedvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentLimitedValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeMaxzcurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZCurrentValue.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeCurrentfeedbackstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.CurrentFeedbackStatus.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeMaxzvaluechangespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.MaxZValueChangeSpeed.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeClosedlooppgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPGain.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasemoveendmodevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveEndModeVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeClosedloopdgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopDGain.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributePhasemovestopbyvalueactivevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.PhaseMoveStopByValueActiveVec.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeActivepidgainset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ActivePIDGainSet.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttributeClosedlooppolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Attribute.ClosedLoopPolarity.SetVectorString', *args)


class RootLuZcontrollerexInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Attribute'
        self.ClosedLoopPolarity = RootLuZcontrollerexInstanceAttributeClosedlooppolarity(self._context)
        self.ActivePIDGainSet = RootLuZcontrollerexInstanceAttributeActivepidgainset(self._context)
        self.PhaseMoveStopByValueActiveVec = RootLuZcontrollerexInstanceAttributePhasemovestopbyvalueactivevec(self._context)
        self.ClosedLoopDGain = RootLuZcontrollerexInstanceAttributeClosedloopdgain(self._context)
        self.PhaseMoveEndModeVec = RootLuZcontrollerexInstanceAttributePhasemoveendmodevec(self._context)
        self.ClosedLoopPGain = RootLuZcontrollerexInstanceAttributeClosedlooppgain(self._context)
        self.MaxZValueChangeSpeed = RootLuZcontrollerexInstanceAttributeMaxzvaluechangespeed(self._context)
        self.CurrentFeedbackStatus = RootLuZcontrollerexInstanceAttributeCurrentfeedbackstatus(self._context)
        self.MaxZCurrentValue = RootLuZcontrollerexInstanceAttributeMaxzcurrentvalue(self._context)
        self.CurrentLimitedValue = RootLuZcontrollerexInstanceAttributeCurrentlimitedvalue(self._context)
        self.ZControllerAdjustTimedOut = RootLuZcontrollerexInstanceAttributeZcontrolleradjusttimedout(self._context)
        self.PhasePauseTimeVec = RootLuZcontrollerexInstanceAttributePhasepausetimevec(self._context)
        self.TargetOutputChannel = RootLuZcontrollerexInstanceAttributeTargetoutputchannel(self._context)
        self.SetPointModulationEnable = RootLuZcontrollerexInstanceAttributeSetpointmodulationenable(self._context)
        self.FeedbackPolarity = RootLuZcontrollerexInstanceAttributeFeedbackpolarity(self._context)
        self.CurrentOutputChannel = RootLuZcontrollerexInstanceAttributeCurrentoutputchannel(self._context)
        self.DdcFilterNumber = RootLuZcontrollerexInstanceAttributeDdcfilternumber(self._context)
        self.IntegralGain = RootLuZcontrollerexInstanceAttributeIntegralgain(self._context)
        self.CurrentOutputValue = RootLuZcontrollerexInstanceAttributeCurrentoutputvalue(self._context)
        self.CtrlInput = RootLuZcontrollerexInstanceAttributeCtrlinput(self._context)
        self.ProportionalGain = RootLuZcontrollerexInstanceAttributeProportionalgain(self._context)
        self.NumberOfPIDGainSets = RootLuZcontrollerexInstanceAttributeNumberofpidgainsets(self._context)
        self.PhaseWorkModeVec = RootLuZcontrollerexInstanceAttributePhaseworkmodevec(self._context)
        self.DifferentialGain = RootLuZcontrollerexInstanceAttributeDifferentialgain(self._context)
        self.PhaseCount = RootLuZcontrollerexInstanceAttributePhasecount(self._context)
        self.CurrentErrorValue = RootLuZcontrollerexInstanceAttributeCurrenterrorvalue(self._context)
        self.DdcFilterRate = RootLuZcontrollerexInstanceAttributeDdcfilterrate(self._context)
        self.PhaseRealEndPosVec = RootLuZcontrollerexInstanceAttributePhaserealendposvec(self._context)
        self.CurrentSumValue = RootLuZcontrollerexInstanceAttributeCurrentsumvalue(self._context)
        self.PhaseMoveValueVec = RootLuZcontrollerexInstanceAttributePhasemovevaluevec(self._context)
        self.EnableMemorySignalGenPosition = RootLuZcontrollerexInstanceAttributeEnablememorysignalgenposition(self._context)
        self.PhaseMoveTimeVec = RootLuZcontrollerexInstanceAttributePhasemovetimevec(self._context)
        self.CurrentInputValue = RootLuZcontrollerexInstanceAttributeCurrentinputvalue(self._context)
        self.FilterCoeffVec = RootLuZcontrollerexInstanceAttributeFiltercoeffvec(self._context)
        self.BaseLinePos = RootLuZcontrollerexInstanceAttributeBaselinepos(self._context)
        self.MaxZValue = RootLuZcontrollerexInstanceAttributeMaxzvalue(self._context)
        self.CurrentInputFilteredValue = RootLuZcontrollerexInstanceAttributeCurrentinputfilteredvalue(self._context)
        self.PhaseInitPhaseCount = RootLuZcontrollerexInstanceAttributePhaseinitphasecount(self._context)
        self.PhaseMoveSpeedVec = RootLuZcontrollerexInstanceAttributePhasemovespeedvec(self._context)
        self.OutputCompareValue = RootLuZcontrollerexInstanceAttributeOutputcomparevalue(self._context)
        self.PhaseMoveModeVec = RootLuZcontrollerexInstanceAttributePhasemovemodevec(self._context)
        self.OutputCompareMode = RootLuZcontrollerexInstanceAttributeOutputcomparemode(self._context)
        self.OuputModulationEnable = RootLuZcontrollerexInstanceAttributeOuputmodulationenable(self._context)
        self.MinZValue = RootLuZcontrollerexInstanceAttributeMinzvalue(self._context)
        self.SetPoint = RootLuZcontrollerexInstanceAttributeSetpoint(self._context)
        self.DdcFilterCoeffVec = RootLuZcontrollerexInstanceAttributeDdcfiltercoeffvec(self._context)
        self.InputCompareValue = RootLuZcontrollerexInstanceAttributeInputcomparevalue(self._context)
        self.InputCompareMode = RootLuZcontrollerexInstanceAttributeInputcomparemode(self._context)
        self.BaseWorkMode = RootLuZcontrollerexInstanceAttributeBaseworkmode(self._context)
        self.EnableMemorySignalGenDrive = RootLuZcontrollerexInstanceAttributeEnablememorysignalgendrive(self._context)
        self.CurrentStatusFlags = RootLuZcontrollerexInstanceAttributeCurrentstatusflags(self._context)
        self.CurrentPhase = RootLuZcontrollerexInstanceAttributeCurrentphase(self._context)
        self.CurrentPIDCommandValue = RootLuZcontrollerexInstanceAttributeCurrentpidcommandvalue(self._context)
        self.ClosedLoopIGain = RootLuZcontrollerexInstanceAttributeClosedloopigain(self._context)


class RootLuZcontrollerexInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.Start', *args)

    def ApplyMaxZValue(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.ApplyMaxZValue', *args)

    def StartSimple(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.StartSimple', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.Stop', *args)

    def InitPhaseMove(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.InitPhaseMove', *args)

    def WaitForZControllerAdjust(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.WaitForZControllerAdjust', *args)

    def UpdateBaseLinePos(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.UpdateBaseLinePos', *args)

    def SwitchToTargetOutputChannel(self, *args) -> Any:
        return self._context.call('root.lu.ZControllerEx.Instance.Trigger.SwitchToTargetOutputChannel', *args)


class RootLuZcontrollerexInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx.Instance'
        self.Trigger = RootLuZcontrollerexInstanceTrigger(self._context)
        self.Attribute = RootLuZcontrollerexInstanceAttribute(self._context)
        self.Busy = RootLuZcontrollerexInstanceBusy(self._context)


class RootLuZcontrollerex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ZControllerEx'
        self.Instance = RootLuZcontrollerexInstance(self._context)


class RootLuRampgeneratorApproachBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Busy.IsMoving', *args)


class RootLuRampgeneratorApproachAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorApproachAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorApproachAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Attribute'
        self.EndValueRelative = RootLuRampgeneratorApproachAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorApproachAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorApproachAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorApproachAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorApproachAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorApproachAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorApproachAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorApproachAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorApproachAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorApproachAttributeStatus(self._context)


class RootLuRampgeneratorApproachTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Approach.Trigger.Stop', *args)


class RootLuRampgeneratorApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Approach'
        self.Trigger = RootLuRampgeneratorApproachTrigger(self._context)
        self.Attribute = RootLuRampgeneratorApproachAttribute(self._context)
        self.Busy = RootLuRampgeneratorApproachBusy(self._context)


class RootLuRampgeneratorVirtual1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Busy.IsMoving', *args)


class RootLuRampgeneratorVirtual1AttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorVirtual1AttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorVirtual1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Attribute'
        self.EndValueRelative = RootLuRampgeneratorVirtual1AttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorVirtual1AttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorVirtual1AttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorVirtual1AttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorVirtual1AttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorVirtual1AttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorVirtual1AttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorVirtual1AttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorVirtual1AttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorVirtual1AttributeStatus(self._context)


class RootLuRampgeneratorVirtual1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual1.Trigger.Stop', *args)


class RootLuRampgeneratorVirtual1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual1'
        self.Trigger = RootLuRampgeneratorVirtual1Trigger(self._context)
        self.Attribute = RootLuRampgeneratorVirtual1Attribute(self._context)
        self.Busy = RootLuRampgeneratorVirtual1Busy(self._context)


class RootLuRampgeneratorTipvoltageBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Busy.IsMoving', *args)


class RootLuRampgeneratorTipvoltageAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorTipvoltageAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Attribute'
        self.EndValueRelative = RootLuRampgeneratorTipvoltageAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorTipvoltageAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorTipvoltageAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorTipvoltageAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorTipvoltageAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorTipvoltageAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorTipvoltageAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorTipvoltageAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorTipvoltageAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorTipvoltageAttributeStatus(self._context)


class RootLuRampgeneratorTipvoltageTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.TipVoltage.Trigger.Stop', *args)


class RootLuRampgeneratorTipvoltage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.TipVoltage'
        self.Trigger = RootLuRampgeneratorTipvoltageTrigger(self._context)
        self.Attribute = RootLuRampgeneratorTipvoltageAttribute(self._context)
        self.Busy = RootLuRampgeneratorTipvoltageBusy(self._context)


class RootLuRampgeneratorUser2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Busy.IsMoving', *args)


class RootLuRampgeneratorUser2AttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorUser2AttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorUser2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Attribute'
        self.EndValueRelative = RootLuRampgeneratorUser2AttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorUser2AttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorUser2AttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorUser2AttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorUser2AttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorUser2AttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorUser2AttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorUser2AttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorUser2AttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorUser2AttributeStatus(self._context)


class RootLuRampgeneratorUser2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User2.Trigger.Stop', *args)


class RootLuRampgeneratorUser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User2'
        self.Trigger = RootLuRampgeneratorUser2Trigger(self._context)
        self.Attribute = RootLuRampgeneratorUser2Attribute(self._context)
        self.Busy = RootLuRampgeneratorUser2Busy(self._context)


class RootLuRampgeneratorControlzBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Busy.IsMoving', *args)


class RootLuRampgeneratorControlzAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorControlzAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorControlzAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Attribute'
        self.EndValueRelative = RootLuRampgeneratorControlzAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorControlzAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorControlzAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorControlzAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorControlzAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorControlzAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorControlzAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorControlzAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorControlzAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorControlzAttributeStatus(self._context)


class RootLuRampgeneratorControlzTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.ControlZ.Trigger.Stop', *args)


class RootLuRampgeneratorControlz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.ControlZ'
        self.Trigger = RootLuRampgeneratorControlzTrigger(self._context)
        self.Attribute = RootLuRampgeneratorControlzAttribute(self._context)
        self.Busy = RootLuRampgeneratorControlzBusy(self._context)


class RootLuRampgeneratorPositionyBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Busy.IsMoving', *args)


class RootLuRampgeneratorPositionyAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorPositionyAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Attribute'
        self.EndValueRelative = RootLuRampgeneratorPositionyAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorPositionyAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorPositionyAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorPositionyAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorPositionyAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorPositionyAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorPositionyAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorPositionyAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorPositionyAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorPositionyAttributeStatus(self._context)


class RootLuRampgeneratorPositionyTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionY.Trigger.Stop', *args)


class RootLuRampgeneratorPositiony(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionY'
        self.Trigger = RootLuRampgeneratorPositionyTrigger(self._context)
        self.Attribute = RootLuRampgeneratorPositionyAttribute(self._context)
        self.Busy = RootLuRampgeneratorPositionyBusy(self._context)


class RootLuRampgeneratorUser4Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Busy.IsMoving', *args)


class RootLuRampgeneratorUser4AttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorUser4AttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorUser4Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Attribute'
        self.EndValueRelative = RootLuRampgeneratorUser4AttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorUser4AttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorUser4AttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorUser4AttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorUser4AttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorUser4AttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorUser4AttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorUser4AttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorUser4AttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorUser4AttributeStatus(self._context)


class RootLuRampgeneratorUser4Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User4.Trigger.Stop', *args)


class RootLuRampgeneratorUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User4'
        self.Trigger = RootLuRampgeneratorUser4Trigger(self._context)
        self.Attribute = RootLuRampgeneratorUser4Attribute(self._context)
        self.Busy = RootLuRampgeneratorUser4Busy(self._context)


class RootLuRampgeneratorVirtual0Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Busy.IsMoving', *args)


class RootLuRampgeneratorVirtual0AttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorVirtual0AttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorVirtual0Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Attribute'
        self.EndValueRelative = RootLuRampgeneratorVirtual0AttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorVirtual0AttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorVirtual0AttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorVirtual0AttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorVirtual0AttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorVirtual0AttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorVirtual0AttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorVirtual0AttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorVirtual0AttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorVirtual0AttributeStatus(self._context)


class RootLuRampgeneratorVirtual0Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual0.Trigger.Stop', *args)


class RootLuRampgeneratorVirtual0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual0'
        self.Trigger = RootLuRampgeneratorVirtual0Trigger(self._context)
        self.Attribute = RootLuRampgeneratorVirtual0Attribute(self._context)
        self.Busy = RootLuRampgeneratorVirtual0Busy(self._context)


class RootLuRampgeneratorTestBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Busy.IsMoving', *args)


class RootLuRampgeneratorTestAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorTestAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorTestAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Attribute'
        self.EndValueRelative = RootLuRampgeneratorTestAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorTestAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorTestAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorTestAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorTestAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorTestAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorTestAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorTestAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorTestAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorTestAttributeStatus(self._context)


class RootLuRampgeneratorTestTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Test.Trigger.Stop', *args)


class RootLuRampgeneratorTest(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Test'
        self.Trigger = RootLuRampgeneratorTestTrigger(self._context)
        self.Attribute = RootLuRampgeneratorTestAttribute(self._context)
        self.Busy = RootLuRampgeneratorTestBusy(self._context)


class RootLuRampgeneratorAlternatezBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Busy.IsMoving', *args)


class RootLuRampgeneratorAlternatezAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorAlternatezAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Attribute'
        self.EndValueRelative = RootLuRampgeneratorAlternatezAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorAlternatezAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorAlternatezAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorAlternatezAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorAlternatezAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorAlternatezAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorAlternatezAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorAlternatezAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorAlternatezAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorAlternatezAttributeStatus(self._context)


class RootLuRampgeneratorAlternatezTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.AlternateZ.Trigger.Stop', *args)


class RootLuRampgeneratorAlternatez(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.AlternateZ'
        self.Trigger = RootLuRampgeneratorAlternatezTrigger(self._context)
        self.Attribute = RootLuRampgeneratorAlternatezAttribute(self._context)
        self.Busy = RootLuRampgeneratorAlternatezBusy(self._context)


class RootLuRampgeneratorPositionxBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Busy.IsMoving', *args)


class RootLuRampgeneratorPositionxAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorPositionxAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Attribute'
        self.EndValueRelative = RootLuRampgeneratorPositionxAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorPositionxAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorPositionxAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorPositionxAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorPositionxAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorPositionxAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorPositionxAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorPositionxAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorPositionxAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorPositionxAttributeStatus(self._context)


class RootLuRampgeneratorPositionxTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PositionX.Trigger.Stop', *args)


class RootLuRampgeneratorPositionx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PositionX'
        self.Trigger = RootLuRampgeneratorPositionxTrigger(self._context)
        self.Attribute = RootLuRampgeneratorPositionxAttribute(self._context)
        self.Busy = RootLuRampgeneratorPositionxBusy(self._context)


class RootLuRampgeneratorVirtual2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Busy.IsMoving', *args)


class RootLuRampgeneratorVirtual2AttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorVirtual2AttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorVirtual2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Attribute'
        self.EndValueRelative = RootLuRampgeneratorVirtual2AttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorVirtual2AttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorVirtual2AttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorVirtual2AttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorVirtual2AttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorVirtual2AttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorVirtual2AttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorVirtual2AttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorVirtual2AttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorVirtual2AttributeStatus(self._context)


class RootLuRampgeneratorVirtual2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.Virtual2.Trigger.Stop', *args)


class RootLuRampgeneratorVirtual2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.Virtual2'
        self.Trigger = RootLuRampgeneratorVirtual2Trigger(self._context)
        self.Attribute = RootLuRampgeneratorVirtual2Attribute(self._context)
        self.Busy = RootLuRampgeneratorVirtual2Busy(self._context)


class RootLuRampgeneratorPlanezBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Busy.IsMoving', *args)


class RootLuRampgeneratorPlanezAttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorPlanezAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Attribute'
        self.EndValueRelative = RootLuRampgeneratorPlanezAttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorPlanezAttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorPlanezAttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorPlanezAttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorPlanezAttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorPlanezAttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorPlanezAttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorPlanezAttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorPlanezAttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorPlanezAttributeStatus(self._context)


class RootLuRampgeneratorPlanezTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.PlaneZ.Trigger.Stop', *args)


class RootLuRampgeneratorPlanez(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.PlaneZ'
        self.Trigger = RootLuRampgeneratorPlanezTrigger(self._context)
        self.Attribute = RootLuRampgeneratorPlanezAttribute(self._context)
        self.Busy = RootLuRampgeneratorPlanezBusy(self._context)


class RootLuRampgeneratorUser1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Busy'

    def IsMoving(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Busy.IsMoving', *args)


class RootLuRampgeneratorUser1AttributeStatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.Status'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.Status.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeEndvalueabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.EndValueAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueAbsolute.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeMovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.MovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingSpeed.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeCurrentvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.CurrentValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.CurrentValue.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeLowerlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.LowerLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.LowerLimit.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeUpperlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.UpperLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.UpperLimit.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeMovingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.MovingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingMode.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeMovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.MovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.MovingTime.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeEndvaluemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.EndValueMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueMode.SetVectorString', *args)


class RootLuRampgeneratorUser1AttributeEndvaluerelative(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute.EndValueRelative'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Attribute.EndValueRelative.SetVectorString', *args)


class RootLuRampgeneratorUser1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Attribute'
        self.EndValueRelative = RootLuRampgeneratorUser1AttributeEndvaluerelative(self._context)
        self.EndValueMode = RootLuRampgeneratorUser1AttributeEndvaluemode(self._context)
        self.MovingTime = RootLuRampgeneratorUser1AttributeMovingtime(self._context)
        self.MovingMode = RootLuRampgeneratorUser1AttributeMovingmode(self._context)
        self.UpperLimit = RootLuRampgeneratorUser1AttributeUpperlimit(self._context)
        self.LowerLimit = RootLuRampgeneratorUser1AttributeLowerlimit(self._context)
        self.CurrentValue = RootLuRampgeneratorUser1AttributeCurrentvalue(self._context)
        self.MovingSpeed = RootLuRampgeneratorUser1AttributeMovingspeed(self._context)
        self.EndValueAbsolute = RootLuRampgeneratorUser1AttributeEndvalueabsolute(self._context)
        self.Status = RootLuRampgeneratorUser1AttributeStatus(self._context)


class RootLuRampgeneratorUser1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Trigger.Start', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Trigger.Prepare', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.RampGenerator.User1.Trigger.Stop', *args)


class RootLuRampgeneratorUser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator.User1'
        self.Trigger = RootLuRampgeneratorUser1Trigger(self._context)
        self.Attribute = RootLuRampgeneratorUser1Attribute(self._context)
        self.Busy = RootLuRampgeneratorUser1Busy(self._context)


class RootLuRampgenerator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.RampGenerator'
        self.User1 = RootLuRampgeneratorUser1(self._context)
        self.PlaneZ = RootLuRampgeneratorPlanez(self._context)
        self.Virtual2 = RootLuRampgeneratorVirtual2(self._context)
        self.PositionX = RootLuRampgeneratorPositionx(self._context)
        self.AlternateZ = RootLuRampgeneratorAlternatez(self._context)
        self.Test = RootLuRampgeneratorTest(self._context)
        self.Virtual0 = RootLuRampgeneratorVirtual0(self._context)
        self.User4 = RootLuRampgeneratorUser4(self._context)
        self.PositionY = RootLuRampgeneratorPositiony(self._context)
        self.ControlZ = RootLuRampgeneratorControlz(self._context)
        self.User2 = RootLuRampgeneratorUser2(self._context)
        self.TipVoltage = RootLuRampgeneratorTipvoltage(self._context)
        self.Virtual1 = RootLuRampgeneratorVirtual1(self._context)
        self.Approach = RootLuRampgeneratorApproach(self._context)


class RootLuPositioncontrolInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Busy'

    def IsBusy(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Busy.IsBusy', *args)

    def IsCalibrating(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Busy.IsCalibrating', *args)

    def IsTipMoving(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Busy.IsTipMoving', *args)

    def IsRangeSwitching(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Busy.IsRangeSwitching', *args)


class RootLuPositioncontrolInstanceAttributeCurrentscanaxisrangeselect(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentScanAxisRangeSelect.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeCurrentposy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.CurrentPosY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosY.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeTargetscanaxisrangeselect(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetScanAxisRangeSelect.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeRampcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.RampCount'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampCount.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeLastmovestopevent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastMoveStopEvent.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeXyclosedloopspeedkeeppos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedKeepPos.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeTargetmoveposz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.TargetMovePosZ'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosZ.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeTargetmovingtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.TargetMovingTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingTime.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeXyclosedloopspeedmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMode.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributePidcontrollersettingsy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsY.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeAxisscalez(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.AxisScaleZ'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZ.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeScancorrectionxrotation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionXRotation.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeLastscanaxisrangeselectswitchresult(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.LastScanAxisRangeSelectSwitchResult.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeCurrentposx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.CurrentPosX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosX.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeXyclosedloopspeedmoving(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.XYClosedLoopSpeedMoving.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeRamptime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.RampTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.RampTime.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeAxisscalezlv(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.AxisScaleZLV'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleZLV.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeIsxyclosedlooppossible(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.IsXYClosedLoopPossible.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeCurrentposz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.CurrentPosZ'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.CurrentPosZ.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeTargetmoveposx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.TargetMovePosX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosX.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeScancorrectionyrotation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.ScanCorrectionYRotation.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeTargetmovingspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovingSpeed.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributePidcontrollersettingsx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.PIDControllerSettingsX.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeAxisscalexy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.AxisScaleXY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXY.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeAxisscalexylv(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.AxisScaleXYLV.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeTargetmoveposy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.TargetMovePosY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.TargetMovePosY.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttributeEnablexyclosedloop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Attribute.EnableXYClosedLoop.SetVectorString', *args)


class RootLuPositioncontrolInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Attribute'
        self.EnableXYClosedLoop = RootLuPositioncontrolInstanceAttributeEnablexyclosedloop(self._context)
        self.TargetMovePosY = RootLuPositioncontrolInstanceAttributeTargetmoveposy(self._context)
        self.AxisScaleXYLV = RootLuPositioncontrolInstanceAttributeAxisscalexylv(self._context)
        self.AxisScaleXY = RootLuPositioncontrolInstanceAttributeAxisscalexy(self._context)
        self.PIDControllerSettingsX = RootLuPositioncontrolInstanceAttributePidcontrollersettingsx(self._context)
        self.TargetMovingSpeed = RootLuPositioncontrolInstanceAttributeTargetmovingspeed(self._context)
        self.ScanCorrectionYRotation = RootLuPositioncontrolInstanceAttributeScancorrectionyrotation(self._context)
        self.TargetMovePosX = RootLuPositioncontrolInstanceAttributeTargetmoveposx(self._context)
        self.CurrentPosZ = RootLuPositioncontrolInstanceAttributeCurrentposz(self._context)
        self.IsXYClosedLoopPossible = RootLuPositioncontrolInstanceAttributeIsxyclosedlooppossible(self._context)
        self.AxisScaleZLV = RootLuPositioncontrolInstanceAttributeAxisscalezlv(self._context)
        self.RampTime = RootLuPositioncontrolInstanceAttributeRamptime(self._context)
        self.XYClosedLoopSpeedMoving = RootLuPositioncontrolInstanceAttributeXyclosedloopspeedmoving(self._context)
        self.CurrentPosX = RootLuPositioncontrolInstanceAttributeCurrentposx(self._context)
        self.LastScanAxisRangeSelectSwitchResult = RootLuPositioncontrolInstanceAttributeLastscanaxisrangeselectswitchresult(self._context)
        self.ScanCorrectionXRotation = RootLuPositioncontrolInstanceAttributeScancorrectionxrotation(self._context)
        self.AxisScaleZ = RootLuPositioncontrolInstanceAttributeAxisscalez(self._context)
        self.PIDControllerSettingsY = RootLuPositioncontrolInstanceAttributePidcontrollersettingsy(self._context)
        self.XYClosedLoopSpeedMode = RootLuPositioncontrolInstanceAttributeXyclosedloopspeedmode(self._context)
        self.TargetMovingTime = RootLuPositioncontrolInstanceAttributeTargetmovingtime(self._context)
        self.TargetMovePosZ = RootLuPositioncontrolInstanceAttributeTargetmoveposz(self._context)
        self.XYClosedLoopSpeedKeepPos = RootLuPositioncontrolInstanceAttributeXyclosedloopspeedkeeppos(self._context)
        self.LastMoveStopEvent = RootLuPositioncontrolInstanceAttributeLastmovestopevent(self._context)
        self.RampCount = RootLuPositioncontrolInstanceAttributeRampcount(self._context)
        self.TargetScanAxisRangeSelect = RootLuPositioncontrolInstanceAttributeTargetscanaxisrangeselect(self._context)
        self.CurrentPosY = RootLuPositioncontrolInstanceAttributeCurrentposy(self._context)
        self.CurrentScanAxisRangeSelect = RootLuPositioncontrolInstanceAttributeCurrentscanaxisrangeselect(self._context)


class RootLuPositioncontrolInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance.Trigger'

    def MoveToTargetFixSpeedXYZ(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.MoveToTargetFixSpeedXYZ', *args)

    def MoveToTargetFixTimeXYZ(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.MoveToTargetFixTimeXYZ', *args)

    def MoveToTargetFixTimeXY(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.MoveToTargetFixTimeXY', *args)

    def StartMoveToTargetFixSpeedXYZ(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.StartMoveToTargetFixSpeedXYZ', *args)

    def StartMoveToTargetFixTimeXYZ(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.StartMoveToTargetFixTimeXYZ', *args)

    def StartCalibXYSensorZeroToCenterOfRamp(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.StartCalibXYSensorZeroToCenterOfRamp', *args)

    def SwitchToTargetScanAxisRangeSelect(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.SwitchToTargetScanAxisRangeSelect', *args)

    def CalibXYSensorZeroToCenterOfRamp(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.CalibXYSensorZeroToCenterOfRamp', *args)

    def StartSwitchToTargetScanAxisRangeSelect(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.StartSwitchToTargetScanAxisRangeSelect', *args)

    def StartMoveToTargetFixTimeXY(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.StartMoveToTargetFixTimeXY', *args)

    def StartMoveToTargetFixSpeedXY(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.StartMoveToTargetFixSpeedXY', *args)

    def MoveToTargetFixSpeedXY(self, *args) -> Any:
        return self._context.call('root.lu.PositionControl.Instance.Trigger.MoveToTargetFixSpeedXY', *args)


class RootLuPositioncontrolInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl.Instance'
        self.Trigger = RootLuPositioncontrolInstanceTrigger(self._context)
        self.Attribute = RootLuPositioncontrolInstanceAttribute(self._context)
        self.Busy = RootLuPositioncontrolInstanceBusy(self._context)


class RootLuPositioncontrol(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PositionControl'
        self.Instance = RootLuPositioncontrolInstance(self._context)


class RootLuDigiuserioInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Busy'


class RootLuDigiuserioInstanceAttributeDigiout2level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Level.SetVectorString', *args)


class RootLuDigiuserioInstanceAttributeDigiin1level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn1Level.SetVectorString', *args)


class RootLuDigiuserioInstanceAttributeDigiout1mode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Mode.SetVectorString', *args)


class RootLuDigiuserioInstanceAttributeDigiin2level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiIn2Level.SetVectorString', *args)


class RootLuDigiuserioInstanceAttributeDigiout2mode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut2Mode.SetVectorString', *args)


class RootLuDigiuserioInstanceAttributeDigiout1level(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Attribute.DigiOut1Level.SetVectorString', *args)


class RootLuDigiuserioInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Attribute'
        self.DigiOut1Level = RootLuDigiuserioInstanceAttributeDigiout1level(self._context)
        self.DigiOut2Mode = RootLuDigiuserioInstanceAttributeDigiout2mode(self._context)
        self.DigiIn2Level = RootLuDigiuserioInstanceAttributeDigiin2level(self._context)
        self.DigiOut1Mode = RootLuDigiuserioInstanceAttributeDigiout1mode(self._context)
        self.DigiIn1Level = RootLuDigiuserioInstanceAttributeDigiin1level(self._context)
        self.DigiOut2Level = RootLuDigiuserioInstanceAttributeDigiout2level(self._context)


class RootLuDigiuserioInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance.Trigger'

    def SyncPulseDigiOut1(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Trigger.SyncPulseDigiOut1', *args)

    def SyncPulseDigiOut2(self, *args) -> Any:
        return self._context.call('root.lu.DigiUserIO.Instance.Trigger.SyncPulseDigiOut2', *args)


class RootLuDigiuserioInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO.Instance'
        self.Trigger = RootLuDigiuserioInstanceTrigger(self._context)
        self.Attribute = RootLuDigiuserioInstanceAttribute(self._context)
        self.Busy = RootLuDigiuserioInstanceBusy(self._context)


class RootLuDigiuserio(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DigiUserIO'
        self.Instance = RootLuDigiuserioInstance(self._context)


class RootLuSysteminfraInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Busy'


class RootLuSysteminfraInstanceAttributeControllertype(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ControllerType'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControllerType.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeExtrain1input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ExtraIn1Input.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeCurrentclocksource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.CurrentClockSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentClockSource.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeAfmsensorstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatus.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeApproachmotorstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatus.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeEnable10hzupdatesensorstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.Enable10HzUpdateSensorStatus.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeFastout2outputmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FastOut2OutputMask.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeLaserpowerlock(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.LaserPowerLock'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerLock.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeLaserpowercurrent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerCurrent.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeHasvideosourcedetection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasVideoSourceDetection.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeLaserpowerabsolute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.LaserPowerAbsolute.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeMainin2input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.MainIn2Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Input.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeScanheadtype(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ScanHeadType'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ScanHeadType.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeHasscanheadtiltdetection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.HasScanheadTiltDetection.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeMainin2coupling(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Coupling.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeTargetclocksource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.TargetClockSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TargetClockSource.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeTipcurrentorinuser3input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipCurrentOrInUser3Input.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeControllaserpower(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ControlLaserPower'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ControlLaserPower.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeApproachmotorstatusnormalized(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorStatusNormalized.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeApproachmotorposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorPosition.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeSensorvaluenormalized(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorValueNormalized.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeMainin1coupling(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Coupling.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeApproachmotormode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.ApproachMotorMode.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeAfmsensorstatusnormalized(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorStatusNormalized.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeDeflectionoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.DeflectionOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.DeflectionOffset.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeSensorlight(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.SensorLight'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.SensorLight.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeInterfaceboxtype(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.InterfaceBoxType.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeTipsignalmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.TipSignalMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.TipSignalMode.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeCurrentcontrollertemperature(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentControllerTemperature.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeCurrentscanheadtiltposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentScanheadTiltPosition.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeAfmsensormode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.AFMSensorMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.AFMSensorMode.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeMainin1gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.MainIn1Gain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn1Gain.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeMainin2gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.MainIn2Gain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.MainIn2Gain.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeCurrentvideosource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.CurrentVideoSource.SetVectorString', *args)


class RootLuSysteminfraInstanceAttributeFrictionnormalized(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute.FrictionNormalized'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Attribute.FrictionNormalized.SetVectorString', *args)


class RootLuSysteminfraInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Attribute'
        self.FrictionNormalized = RootLuSysteminfraInstanceAttributeFrictionnormalized(self._context)
        self.CurrentVideoSource = RootLuSysteminfraInstanceAttributeCurrentvideosource(self._context)
        self.MainIn2Gain = RootLuSysteminfraInstanceAttributeMainin2gain(self._context)
        self.MainIn1Gain = RootLuSysteminfraInstanceAttributeMainin1gain(self._context)
        self.AFMSensorMode = RootLuSysteminfraInstanceAttributeAfmsensormode(self._context)
        self.CurrentScanheadTiltPosition = RootLuSysteminfraInstanceAttributeCurrentscanheadtiltposition(self._context)
        self.CurrentControllerTemperature = RootLuSysteminfraInstanceAttributeCurrentcontrollertemperature(self._context)
        self.TipSignalMode = RootLuSysteminfraInstanceAttributeTipsignalmode(self._context)
        self.InterfaceBoxType = RootLuSysteminfraInstanceAttributeInterfaceboxtype(self._context)
        self.SensorLight = RootLuSysteminfraInstanceAttributeSensorlight(self._context)
        self.DeflectionOffset = RootLuSysteminfraInstanceAttributeDeflectionoffset(self._context)
        self.AFMSensorStatusNormalized = RootLuSysteminfraInstanceAttributeAfmsensorstatusnormalized(self._context)
        self.ApproachMotorMode = RootLuSysteminfraInstanceAttributeApproachmotormode(self._context)
        self.MainIn1Coupling = RootLuSysteminfraInstanceAttributeMainin1coupling(self._context)
        self.SensorValueNormalized = RootLuSysteminfraInstanceAttributeSensorvaluenormalized(self._context)
        self.ApproachMotorPosition = RootLuSysteminfraInstanceAttributeApproachmotorposition(self._context)
        self.ApproachMotorStatusNormalized = RootLuSysteminfraInstanceAttributeApproachmotorstatusnormalized(self._context)
        self.ControlLaserPower = RootLuSysteminfraInstanceAttributeControllaserpower(self._context)
        self.TipCurrentOrInUser3Input = RootLuSysteminfraInstanceAttributeTipcurrentorinuser3input(self._context)
        self.TargetClockSource = RootLuSysteminfraInstanceAttributeTargetclocksource(self._context)
        self.MainIn2Coupling = RootLuSysteminfraInstanceAttributeMainin2coupling(self._context)
        self.HasScanheadTiltDetection = RootLuSysteminfraInstanceAttributeHasscanheadtiltdetection(self._context)
        self.ScanHeadType = RootLuSysteminfraInstanceAttributeScanheadtype(self._context)
        self.MainIn2Input = RootLuSysteminfraInstanceAttributeMainin2input(self._context)
        self.LaserPowerAbsolute = RootLuSysteminfraInstanceAttributeLaserpowerabsolute(self._context)
        self.HasVideoSourceDetection = RootLuSysteminfraInstanceAttributeHasvideosourcedetection(self._context)
        self.LaserPowerCurrent = RootLuSysteminfraInstanceAttributeLaserpowercurrent(self._context)
        self.LaserPowerLock = RootLuSysteminfraInstanceAttributeLaserpowerlock(self._context)
        self.FastOut2OutputMask = RootLuSysteminfraInstanceAttributeFastout2outputmask(self._context)
        self.Enable10HzUpdateSensorStatus = RootLuSysteminfraInstanceAttributeEnable10hzupdatesensorstatus(self._context)
        self.ApproachMotorStatus = RootLuSysteminfraInstanceAttributeApproachmotorstatus(self._context)
        self.AFMSensorStatus = RootLuSysteminfraInstanceAttributeAfmsensorstatus(self._context)
        self.CurrentClockSource = RootLuSysteminfraInstanceAttributeCurrentclocksource(self._context)
        self.ExtraIn1Input = RootLuSysteminfraInstanceAttributeExtrain1input(self._context)
        self.ControllerType = RootLuSysteminfraInstanceAttributeControllertype(self._context)


class RootLuSysteminfraInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance.Trigger'

    def SwitchClockSource(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Trigger.SwitchClockSource', *args)

    def DetectScanHeadArrivalRemoval(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Trigger.DetectScanHeadArrivalRemoval', *args)

    def DetectScanHeadLeverChange(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Trigger.DetectScanHeadLeverChange', *args)

    def DetectLimitSwitchStatusInfoChange(self, *args) -> Any:
        return self._context.call('root.lu.SystemInfra.Instance.Trigger.DetectLimitSwitchStatusInfoChange', *args)


class RootLuSysteminfraInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra.Instance'
        self.Trigger = RootLuSysteminfraInstanceTrigger(self._context)
        self.Attribute = RootLuSysteminfraInstanceAttribute(self._context)
        self.Busy = RootLuSysteminfraInstanceBusy(self._context)


class RootLuSysteminfra(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SystemInfra'
        self.Instance = RootLuSysteminfraInstance(self._context)


class RootLuAnalogfastoutFast3Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Busy'


class RootLuAnalogfastoutFast3AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Modulation.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.Input.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeAnalogoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.AnalogOutput.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeDampinggain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.DampingGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.DampingGain.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnalogfastoutFast3AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast3.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnalogfastoutFast3Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Attribute'
        self.CalibGain = RootLuAnalogfastoutFast3AttributeCalibgain(self._context)
        self.OutputGain = RootLuAnalogfastoutFast3AttributeOutputgain(self._context)
        self.OutputOffset = RootLuAnalogfastoutFast3AttributeOutputoffset(self._context)
        self.DampingGain = RootLuAnalogfastoutFast3AttributeDampinggain(self._context)
        self.AnalogOutput = RootLuAnalogfastoutFast3AttributeAnalogoutput(self._context)
        self.CalibSigSourceDir = RootLuAnalogfastoutFast3AttributeCalibsigsourcedir(self._context)
        self.StaticValue = RootLuAnalogfastoutFast3AttributeStaticvalue(self._context)
        self.Input = RootLuAnalogfastoutFast3AttributeInput(self._context)
        self.CurrentOutputValue = RootLuAnalogfastoutFast3AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnalogfastoutFast3AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnalogfastoutFast3AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnalogfastoutFast3AttributeCaliboffset(self._context)


class RootLuAnalogfastoutFast3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3.Trigger'


class RootLuAnalogfastoutFast3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast3'
        self.Trigger = RootLuAnalogfastoutFast3Trigger(self._context)
        self.Attribute = RootLuAnalogfastoutFast3Attribute(self._context)
        self.Busy = RootLuAnalogfastoutFast3Busy(self._context)


class RootLuAnalogfastoutExcitationBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Busy'


class RootLuAnalogfastoutExcitationAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Modulation.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.Input.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeAnalogoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.AnalogOutput.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeDampinggain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.DampingGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.DampingGain.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Excitation.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnalogfastoutExcitationAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Attribute'
        self.CalibGain = RootLuAnalogfastoutExcitationAttributeCalibgain(self._context)
        self.OutputGain = RootLuAnalogfastoutExcitationAttributeOutputgain(self._context)
        self.OutputOffset = RootLuAnalogfastoutExcitationAttributeOutputoffset(self._context)
        self.DampingGain = RootLuAnalogfastoutExcitationAttributeDampinggain(self._context)
        self.AnalogOutput = RootLuAnalogfastoutExcitationAttributeAnalogoutput(self._context)
        self.CalibSigSourceDir = RootLuAnalogfastoutExcitationAttributeCalibsigsourcedir(self._context)
        self.StaticValue = RootLuAnalogfastoutExcitationAttributeStaticvalue(self._context)
        self.Input = RootLuAnalogfastoutExcitationAttributeInput(self._context)
        self.CurrentOutputValue = RootLuAnalogfastoutExcitationAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnalogfastoutExcitationAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnalogfastoutExcitationAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnalogfastoutExcitationAttributeCaliboffset(self._context)


class RootLuAnalogfastoutExcitationTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation.Trigger'


class RootLuAnalogfastoutExcitation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Excitation'
        self.Trigger = RootLuAnalogfastoutExcitationTrigger(self._context)
        self.Attribute = RootLuAnalogfastoutExcitationAttribute(self._context)
        self.Busy = RootLuAnalogfastoutExcitationBusy(self._context)


class RootLuAnalogfastoutUserBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Busy'


class RootLuAnalogfastoutUserAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Modulation.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.Input.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeAnalogoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.AnalogOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.AnalogOutput.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeDampinggain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.DampingGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.DampingGain.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnalogfastoutUserAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.User.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnalogfastoutUserAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Attribute'
        self.CalibGain = RootLuAnalogfastoutUserAttributeCalibgain(self._context)
        self.OutputGain = RootLuAnalogfastoutUserAttributeOutputgain(self._context)
        self.OutputOffset = RootLuAnalogfastoutUserAttributeOutputoffset(self._context)
        self.DampingGain = RootLuAnalogfastoutUserAttributeDampinggain(self._context)
        self.AnalogOutput = RootLuAnalogfastoutUserAttributeAnalogoutput(self._context)
        self.CalibSigSourceDir = RootLuAnalogfastoutUserAttributeCalibsigsourcedir(self._context)
        self.StaticValue = RootLuAnalogfastoutUserAttributeStaticvalue(self._context)
        self.Input = RootLuAnalogfastoutUserAttributeInput(self._context)
        self.CurrentOutputValue = RootLuAnalogfastoutUserAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnalogfastoutUserAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnalogfastoutUserAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnalogfastoutUserAttributeCaliboffset(self._context)


class RootLuAnalogfastoutUserTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User.Trigger'


class RootLuAnalogfastoutUser(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.User'
        self.Trigger = RootLuAnalogfastoutUserTrigger(self._context)
        self.Attribute = RootLuAnalogfastoutUserAttribute(self._context)
        self.Busy = RootLuAnalogfastoutUserBusy(self._context)


class RootLuAnalogfastoutFast2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Busy'


class RootLuAnalogfastoutFast2AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Modulation.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.Input.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeAnalogoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.AnalogOutput.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeDampinggain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.DampingGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.DampingGain.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnalogfastoutFast2AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogFastOut.Fast2.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnalogfastoutFast2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Attribute'
        self.CalibGain = RootLuAnalogfastoutFast2AttributeCalibgain(self._context)
        self.OutputGain = RootLuAnalogfastoutFast2AttributeOutputgain(self._context)
        self.OutputOffset = RootLuAnalogfastoutFast2AttributeOutputoffset(self._context)
        self.DampingGain = RootLuAnalogfastoutFast2AttributeDampinggain(self._context)
        self.AnalogOutput = RootLuAnalogfastoutFast2AttributeAnalogoutput(self._context)
        self.CalibSigSourceDir = RootLuAnalogfastoutFast2AttributeCalibsigsourcedir(self._context)
        self.StaticValue = RootLuAnalogfastoutFast2AttributeStaticvalue(self._context)
        self.Input = RootLuAnalogfastoutFast2AttributeInput(self._context)
        self.CurrentOutputValue = RootLuAnalogfastoutFast2AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnalogfastoutFast2AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnalogfastoutFast2AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnalogfastoutFast2AttributeCaliboffset(self._context)


class RootLuAnalogfastoutFast2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2.Trigger'


class RootLuAnalogfastoutFast2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut.Fast2'
        self.Trigger = RootLuAnalogfastoutFast2Trigger(self._context)
        self.Attribute = RootLuAnalogfastoutFast2Attribute(self._context)
        self.Busy = RootLuAnalogfastoutFast2Busy(self._context)


class RootLuAnalogfastout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogFastOut'
        self.Fast2 = RootLuAnalogfastoutFast2(self._context)
        self.User = RootLuAnalogfastoutUser(self._context)
        self.Excitation = RootLuAnalogfastoutExcitation(self._context)
        self.Fast3 = RootLuAnalogfastoutFast3(self._context)


class RootLuCantileverpropertiesInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Busy'


class RootLuCantileverpropertiesInstanceAttributeDeflectionsensitivity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.DeflectionSensitivity.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeLength(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.Length'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Length.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeTipradius(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.TipRadius'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipRadius.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeAlignstrategy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.AlignStrategy'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.AlignStrategy.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeTiphalfangle(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.TipHalfAngle.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeShape(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.Shape'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Shape.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeQfactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.QFactor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.QFactor.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeWidth(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.Width'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.Width.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeSpringconstant(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.SpringConstant'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.SpringConstant.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttributeResonancefrequency(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CantileverProperties.Instance.Attribute.ResonanceFrequency.SetVectorString', *args)


class RootLuCantileverpropertiesInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Attribute'
        self.ResonanceFrequency = RootLuCantileverpropertiesInstanceAttributeResonancefrequency(self._context)
        self.SpringConstant = RootLuCantileverpropertiesInstanceAttributeSpringconstant(self._context)
        self.Width = RootLuCantileverpropertiesInstanceAttributeWidth(self._context)
        self.QFactor = RootLuCantileverpropertiesInstanceAttributeQfactor(self._context)
        self.Shape = RootLuCantileverpropertiesInstanceAttributeShape(self._context)
        self.TipHalfAngle = RootLuCantileverpropertiesInstanceAttributeTiphalfangle(self._context)
        self.AlignStrategy = RootLuCantileverpropertiesInstanceAttributeAlignstrategy(self._context)
        self.TipRadius = RootLuCantileverpropertiesInstanceAttributeTipradius(self._context)
        self.Length = RootLuCantileverpropertiesInstanceAttributeLength(self._context)
        self.DeflectionSensitivity = RootLuCantileverpropertiesInstanceAttributeDeflectionsensitivity(self._context)


class RootLuCantileverpropertiesInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance.Trigger'


class RootLuCantileverpropertiesInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties.Instance'
        self.Trigger = RootLuCantileverpropertiesInstanceTrigger(self._context)
        self.Attribute = RootLuCantileverpropertiesInstanceAttribute(self._context)
        self.Busy = RootLuCantileverpropertiesInstanceBusy(self._context)


class RootLuCantileverproperties(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CantileverProperties'
        self.Instance = RootLuCantileverpropertiesInstance(self._context)


class RootLuAnaloghiresoutPositionwBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Busy'


class RootLuAnaloghiresoutPositionwAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionW.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionwAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Attribute'
        self.OutputGain = RootLuAnaloghiresoutPositionwAttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutPositionwAttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutPositionwAttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutPositionwAttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutPositionwAttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutPositionwAttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutPositionwAttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutPositionwAttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutPositionwAttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutPositionwAttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutPositionwAttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutPositionwAttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutPositionwAttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutPositionwAttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutPositionwAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutPositionwAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutPositionwAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutPositionwAttributeCaliboffset(self._context)


class RootLuAnaloghiresoutPositionwTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW.Trigger'


class RootLuAnaloghiresoutPositionw(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionW'
        self.Trigger = RootLuAnaloghiresoutPositionwTrigger(self._context)
        self.Attribute = RootLuAnaloghiresoutPositionwAttribute(self._context)
        self.Busy = RootLuAnaloghiresoutPositionwBusy(self._context)


class RootLuAnaloghiresoutOut8Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Busy'


class RootLuAnaloghiresoutOut8AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutOut8AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out8.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutOut8Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Attribute'
        self.OutputGain = RootLuAnaloghiresoutOut8AttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutOut8AttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutOut8AttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutOut8AttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutOut8AttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutOut8AttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutOut8AttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutOut8AttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutOut8AttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutOut8AttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutOut8AttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutOut8AttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutOut8AttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutOut8AttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutOut8AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutOut8AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutOut8AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutOut8AttributeCaliboffset(self._context)


class RootLuAnaloghiresoutOut8Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8.Trigger'


class RootLuAnaloghiresoutOut8(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out8'
        self.Trigger = RootLuAnaloghiresoutOut8Trigger(self._context)
        self.Attribute = RootLuAnaloghiresoutOut8Attribute(self._context)
        self.Busy = RootLuAnaloghiresoutOut8Busy(self._context)


class RootLuAnaloghiresoutOut7Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Busy'


class RootLuAnaloghiresoutOut7AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutOut7AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Out7.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutOut7Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Attribute'
        self.OutputGain = RootLuAnaloghiresoutOut7AttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutOut7AttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutOut7AttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutOut7AttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutOut7AttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutOut7AttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutOut7AttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutOut7AttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutOut7AttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutOut7AttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutOut7AttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutOut7AttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutOut7AttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutOut7AttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutOut7AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutOut7AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutOut7AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutOut7AttributeCaliboffset(self._context)


class RootLuAnaloghiresoutOut7Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7.Trigger'


class RootLuAnaloghiresoutOut7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Out7'
        self.Trigger = RootLuAnaloghiresoutOut7Trigger(self._context)
        self.Attribute = RootLuAnaloghiresoutOut7Attribute(self._context)
        self.Busy = RootLuAnaloghiresoutOut7Busy(self._context)


class RootLuAnaloghiresoutTipvoltageBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Busy'


class RootLuAnaloghiresoutTipvoltageAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.TipVoltage.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutTipvoltageAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Attribute'
        self.OutputGain = RootLuAnaloghiresoutTipvoltageAttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutTipvoltageAttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutTipvoltageAttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutTipvoltageAttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutTipvoltageAttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutTipvoltageAttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutTipvoltageAttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutTipvoltageAttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutTipvoltageAttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutTipvoltageAttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutTipvoltageAttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutTipvoltageAttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutTipvoltageAttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutTipvoltageAttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutTipvoltageAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutTipvoltageAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutTipvoltageAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutTipvoltageAttributeCaliboffset(self._context)


class RootLuAnaloghiresoutTipvoltageTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage.Trigger'


class RootLuAnaloghiresoutTipvoltage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.TipVoltage'
        self.Trigger = RootLuAnaloghiresoutTipvoltageTrigger(self._context)
        self.Attribute = RootLuAnaloghiresoutTipvoltageAttribute(self._context)
        self.Busy = RootLuAnaloghiresoutTipvoltageBusy(self._context)


class RootLuAnaloghiresoutUser2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Busy'


class RootLuAnaloghiresoutUser2AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutUser2AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User2.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Attribute'
        self.OutputGain = RootLuAnaloghiresoutUser2AttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutUser2AttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutUser2AttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutUser2AttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutUser2AttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutUser2AttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutUser2AttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutUser2AttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutUser2AttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutUser2AttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutUser2AttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutUser2AttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutUser2AttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutUser2AttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutUser2AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutUser2AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutUser2AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutUser2AttributeCaliboffset(self._context)


class RootLuAnaloghiresoutUser2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2.Trigger'


class RootLuAnaloghiresoutUser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User2'
        self.Trigger = RootLuAnaloghiresoutUser2Trigger(self._context)
        self.Attribute = RootLuAnaloghiresoutUser2Attribute(self._context)
        self.Busy = RootLuAnaloghiresoutUser2Busy(self._context)


class RootLuAnaloghiresoutPositionyBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Busy'


class RootLuAnaloghiresoutPositionyAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionY.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionyAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Attribute'
        self.OutputGain = RootLuAnaloghiresoutPositionyAttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutPositionyAttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutPositionyAttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutPositionyAttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutPositionyAttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutPositionyAttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutPositionyAttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutPositionyAttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutPositionyAttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutPositionyAttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutPositionyAttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutPositionyAttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutPositionyAttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutPositionyAttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutPositionyAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutPositionyAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutPositionyAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutPositionyAttributeCaliboffset(self._context)


class RootLuAnaloghiresoutPositionyTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY.Trigger'


class RootLuAnaloghiresoutPositiony(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionY'
        self.Trigger = RootLuAnaloghiresoutPositionyTrigger(self._context)
        self.Attribute = RootLuAnaloghiresoutPositionyAttribute(self._context)
        self.Busy = RootLuAnaloghiresoutPositionyBusy(self._context)


class RootLuAnaloghiresoutUser4Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Busy'


class RootLuAnaloghiresoutUser4AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutUser4AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User4.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser4Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Attribute'
        self.OutputGain = RootLuAnaloghiresoutUser4AttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutUser4AttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutUser4AttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutUser4AttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutUser4AttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutUser4AttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutUser4AttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutUser4AttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutUser4AttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutUser4AttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutUser4AttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutUser4AttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutUser4AttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutUser4AttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutUser4AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutUser4AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutUser4AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutUser4AttributeCaliboffset(self._context)


class RootLuAnaloghiresoutUser4Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4.Trigger'


class RootLuAnaloghiresoutUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User4'
        self.Trigger = RootLuAnaloghiresoutUser4Trigger(self._context)
        self.Attribute = RootLuAnaloghiresoutUser4Attribute(self._context)
        self.Busy = RootLuAnaloghiresoutUser4Busy(self._context)


class RootLuAnaloghiresoutPositionzBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Busy'


class RootLuAnaloghiresoutPositionzAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionZ.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionzAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Attribute'
        self.OutputGain = RootLuAnaloghiresoutPositionzAttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutPositionzAttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutPositionzAttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutPositionzAttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutPositionzAttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutPositionzAttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutPositionzAttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutPositionzAttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutPositionzAttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutPositionzAttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutPositionzAttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutPositionzAttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutPositionzAttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutPositionzAttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutPositionzAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutPositionzAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutPositionzAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutPositionzAttributeCaliboffset(self._context)


class RootLuAnaloghiresoutPositionzTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ.Trigger'


class RootLuAnaloghiresoutPositionz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionZ'
        self.Trigger = RootLuAnaloghiresoutPositionzTrigger(self._context)
        self.Attribute = RootLuAnaloghiresoutPositionzAttribute(self._context)
        self.Busy = RootLuAnaloghiresoutPositionzBusy(self._context)


class RootLuAnaloghiresoutApproachBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Busy'


class RootLuAnaloghiresoutApproachAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.Approach.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutApproachAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Attribute'
        self.OutputGain = RootLuAnaloghiresoutApproachAttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutApproachAttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutApproachAttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutApproachAttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutApproachAttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutApproachAttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutApproachAttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutApproachAttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutApproachAttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutApproachAttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutApproachAttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutApproachAttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutApproachAttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutApproachAttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutApproachAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutApproachAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutApproachAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutApproachAttributeCaliboffset(self._context)


class RootLuAnaloghiresoutApproachTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach.Trigger'


class RootLuAnaloghiresoutApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.Approach'
        self.Trigger = RootLuAnaloghiresoutApproachTrigger(self._context)
        self.Attribute = RootLuAnaloghiresoutApproachAttribute(self._context)
        self.Busy = RootLuAnaloghiresoutApproachBusy(self._context)


class RootLuAnaloghiresoutPositionxBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Busy'


class RootLuAnaloghiresoutPositionxAttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.PositionX.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutPositionxAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Attribute'
        self.OutputGain = RootLuAnaloghiresoutPositionxAttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutPositionxAttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutPositionxAttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutPositionxAttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutPositionxAttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutPositionxAttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutPositionxAttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutPositionxAttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutPositionxAttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutPositionxAttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutPositionxAttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutPositionxAttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutPositionxAttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutPositionxAttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutPositionxAttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutPositionxAttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutPositionxAttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutPositionxAttributeCaliboffset(self._context)


class RootLuAnaloghiresoutPositionxTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX.Trigger'


class RootLuAnaloghiresoutPositionx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.PositionX'
        self.Trigger = RootLuAnaloghiresoutPositionxTrigger(self._context)
        self.Attribute = RootLuAnaloghiresoutPositionxAttribute(self._context)
        self.Busy = RootLuAnaloghiresoutPositionxBusy(self._context)


class RootLuAnaloghiresoutUser1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Busy'


class RootLuAnaloghiresoutUser1AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutUser1AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User1.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Attribute'
        self.OutputGain = RootLuAnaloghiresoutUser1AttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutUser1AttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutUser1AttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutUser1AttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutUser1AttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutUser1AttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutUser1AttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutUser1AttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutUser1AttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutUser1AttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutUser1AttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutUser1AttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutUser1AttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutUser1AttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutUser1AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutUser1AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutUser1AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutUser1AttributeCaliboffset(self._context)


class RootLuAnaloghiresoutUser1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1.Trigger'


class RootLuAnaloghiresoutUser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User1'
        self.Trigger = RootLuAnaloghiresoutUser1Trigger(self._context)
        self.Attribute = RootLuAnaloghiresoutUser1Attribute(self._context)
        self.Busy = RootLuAnaloghiresoutUser1Busy(self._context)


class RootLuAnaloghiresoutUser3Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Busy'


class RootLuAnaloghiresoutUser3AttributeCaliboffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.CalibOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeCalibpolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibPolarity.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeModulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.Modulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Modulation.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeCurrentoutputvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CurrentOutputValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeModulationinput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.ModulationInput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.ModulationInput.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeSlewrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.SlewRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.SlewRate.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeGlitchcorrenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrEnabled.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeStaticvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.StaticValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.StaticValue.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeFilternumber(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.FilterNumber'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterNumber.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeOutputoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.OutputOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputOffset.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeCalibgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.CalibGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeCaliblowordgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.Input.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeGlitchcorrbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.GlitchCorrBinaryVec.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeCalibsigsourcedir(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibSigSourceDir.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeCalibloworddelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.CalibLoWordDelay.SetVectorString', *args)


class RootLuAnaloghiresoutUser3AttributeOutputgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute.OutputGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.AnalogHiResOut.User3.Attribute.OutputGain.SetVectorString', *args)


class RootLuAnaloghiresoutUser3Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Attribute'
        self.OutputGain = RootLuAnaloghiresoutUser3AttributeOutputgain(self._context)
        self.CalibLoWordDelay = RootLuAnaloghiresoutUser3AttributeCalibloworddelay(self._context)
        self.CalibSigSourceDir = RootLuAnaloghiresoutUser3AttributeCalibsigsourcedir(self._context)
        self.GlitchCorrBinaryVec = RootLuAnaloghiresoutUser3AttributeGlitchcorrbinaryvec(self._context)
        self.FilterCoeffVec = RootLuAnaloghiresoutUser3AttributeFiltercoeffvec(self._context)
        self.Input = RootLuAnaloghiresoutUser3AttributeInput(self._context)
        self.CalibLoWordGain = RootLuAnaloghiresoutUser3AttributeCaliblowordgain(self._context)
        self.CalibGain = RootLuAnaloghiresoutUser3AttributeCalibgain(self._context)
        self.OutputOffset = RootLuAnaloghiresoutUser3AttributeOutputoffset(self._context)
        self.FilterNumber = RootLuAnaloghiresoutUser3AttributeFilternumber(self._context)
        self.StaticValue = RootLuAnaloghiresoutUser3AttributeStaticvalue(self._context)
        self.GlitchCorrEnabled = RootLuAnaloghiresoutUser3AttributeGlitchcorrenabled(self._context)
        self.SlewRate = RootLuAnaloghiresoutUser3AttributeSlewrate(self._context)
        self.ModulationInput = RootLuAnaloghiresoutUser3AttributeModulationinput(self._context)
        self.CurrentOutputValue = RootLuAnaloghiresoutUser3AttributeCurrentoutputvalue(self._context)
        self.Modulation = RootLuAnaloghiresoutUser3AttributeModulation(self._context)
        self.CalibPolarity = RootLuAnaloghiresoutUser3AttributeCalibpolarity(self._context)
        self.CalibOffset = RootLuAnaloghiresoutUser3AttributeCaliboffset(self._context)


class RootLuAnaloghiresoutUser3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3.Trigger'


class RootLuAnaloghiresoutUser3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut.User3'
        self.Trigger = RootLuAnaloghiresoutUser3Trigger(self._context)
        self.Attribute = RootLuAnaloghiresoutUser3Attribute(self._context)
        self.Busy = RootLuAnaloghiresoutUser3Busy(self._context)


class RootLuAnaloghiresout(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.AnalogHiResOut'
        self.User3 = RootLuAnaloghiresoutUser3(self._context)
        self.User1 = RootLuAnaloghiresoutUser1(self._context)
        self.PositionX = RootLuAnaloghiresoutPositionx(self._context)
        self.Approach = RootLuAnaloghiresoutApproach(self._context)
        self.PositionZ = RootLuAnaloghiresoutPositionz(self._context)
        self.User4 = RootLuAnaloghiresoutUser4(self._context)
        self.PositionY = RootLuAnaloghiresoutPositiony(self._context)
        self.User2 = RootLuAnaloghiresoutUser2(self._context)
        self.TipVoltage = RootLuAnaloghiresoutTipvoltage(self._context)
        self.Out7 = RootLuAnaloghiresoutOut7(self._context)
        self.Out8 = RootLuAnaloghiresoutOut8(self._context)
        self.PositionW = RootLuAnaloghiresoutPositionw(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 RootLuSpecInstanceAttributeBwdpausemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdPauseMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseMode.SetVectorString', *args)


class RootLuSpecInstanceAttributeFeedbackactive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FeedbackActive'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FeedbackActive.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdmovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdMoveSpeed.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdmodtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdModTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModTime.SetVectorString', *args)


class RootLuSpecInstanceAttributeModulationoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.ModulationOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModulationOutput.SetVectorString', *args)


class RootLuSpecInstanceAttributePhasefwdpauserate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdPauseRate.SetVectorString', *args)


class RootLuSpecInstanceAttributePhasesamplemask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.PhaseSampleMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseSampleMask.SetVectorString', *args)


class RootLuSpecInstanceAttributeRepetitioncount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.RepetitionCount'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionCount.SetVectorString', *args)


class RootLuSpecInstanceAttributeStartoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.StartOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffset.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdmodrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdModRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModRange.SetVectorString', *args)


class RootLuSpecInstanceAttributeDeflectionforceoffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.DeflectionForceOffset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.DeflectionForceOffset.SetVectorString', *args)


class RootLuSpecInstanceAttributeSpecendmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.SpecEndMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecEndMode.SetVectorString', *args)


class RootLuSpecInstanceAttributeSpecmapmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.SpecMapMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapMode.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdmodrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdModRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModRange.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdmovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdMoveSpeed.SetVectorString', *args)


class RootLuSpecInstanceAttributeRepetitionmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.RepetitionMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.RepetitionMode.SetVectorString', *args)


class RootLuSpecInstanceAttributeXymovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.XYMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.XYMoveSpeed.SetVectorString', *args)


class RootLuSpecInstanceAttributeSpecmapconfigurationblobvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.SpecMapConfigurationBlobVec.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdpausedatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdPauseDatapoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseDatapoints.SetVectorString', *args)


class RootLuSpecInstanceAttributePhasedatagroupid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.PhaseDataGroupId'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseDataGroupId.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdpausedatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdPauseDatapoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseDatapoints.SetVectorString', *args)


class RootLuSpecInstanceAttributeCurrentrepetition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.CurrentRepetition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.CurrentRepetition.SetVectorString', *args)


class RootLuSpecInstanceAttributeAutorecalibrateprobeinterval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.AutoRecalibrateProbeInterval.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdmodtime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdModTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModTime.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwddatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdDatapoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdDatapoints.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdpausetime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdPauseTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdPauseTime.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdmodmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdModMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModMode.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwddatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdDatapoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdDatapoints.SetVectorString', *args)


class RootLuSpecInstanceAttributePhasefwdmodrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.PhaseFwdModRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseFwdModRate.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdmodstopvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdModStopValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopValue.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdmodstopvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdModStopValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopValue.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdpausetime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdPauseTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseTime.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdpausemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdPauseMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdPauseMode.SetVectorString', *args)


class RootLuSpecInstanceAttributePhasebwdmodrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.PhaseBwdModRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdModRate.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdmodstopmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdModStopMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModStopMode.SetVectorString', *args)


class RootLuSpecInstanceAttributePointcoordsblobvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.PointCoordsBlobVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PointCoordsBlobVec.SetVectorString', *args)


class RootLuSpecInstanceAttributeModrelvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.ModRelValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.ModRelValue.SetVectorString', *args)


class RootLuSpecInstanceAttributeStartoffsetmovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.StartOffsetMoveSpeed.SetVectorString', *args)


class RootLuSpecInstanceAttributeFwdmodstopmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.FwdModStopMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.FwdModStopMode.SetVectorString', *args)


class RootLuSpecInstanceAttributePhasebwdpauserate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.PhaseBwdPauseRate.SetVectorString', *args)


class RootLuSpecInstanceAttributeBwdmodmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute.BwdModMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Attribute.BwdModMode.SetVectorString', *args)


class RootLuSpecInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Attribute'
        self.BwdModMode = RootLuSpecInstanceAttributeBwdmodmode(self._context)
        self.PhaseBwdPauseRate = RootLuSpecInstanceAttributePhasebwdpauserate(self._context)
        self.FwdModStopMode = RootLuSpecInstanceAttributeFwdmodstopmode(self._context)
        self.StartOffsetMoveSpeed = RootLuSpecInstanceAttributeStartoffsetmovespeed(self._context)
        self.ModRelValue = RootLuSpecInstanceAttributeModrelvalue(self._context)
        self.PointCoordsBlobVec = RootLuSpecInstanceAttributePointcoordsblobvec(self._context)
        self.BwdModStopMode = RootLuSpecInstanceAttributeBwdmodstopmode(self._context)
        self.PhaseBwdModRate = RootLuSpecInstanceAttributePhasebwdmodrate(self._context)
        self.FwdPauseMode = RootLuSpecInstanceAttributeFwdpausemode(self._context)
        self.FwdPauseTime = RootLuSpecInstanceAttributeFwdpausetime(self._context)
        self.BwdModStopValue = RootLuSpecInstanceAttributeBwdmodstopvalue(self._context)
        self.FwdModStopValue = RootLuSpecInstanceAttributeFwdmodstopvalue(self._context)
        self.PhaseFwdModRate = RootLuSpecInstanceAttributePhasefwdmodrate(self._context)
        self.FwdDatapoints = RootLuSpecInstanceAttributeFwddatapoints(self._context)
        self.FwdModMode = RootLuSpecInstanceAttributeFwdmodmode(self._context)
        self.BwdPauseTime = RootLuSpecInstanceAttributeBwdpausetime(self._context)
        self.BwdDatapoints = RootLuSpecInstanceAttributeBwddatapoints(self._context)
        self.BwdModTime = RootLuSpecInstanceAttributeBwdmodtime(self._context)
        self.AutoRecalibrateProbeInterval = RootLuSpecInstanceAttributeAutorecalibrateprobeinterval(self._context)
        self.CurrentRepetition = RootLuSpecInstanceAttributeCurrentrepetition(self._context)
        self.BwdPauseDatapoints = RootLuSpecInstanceAttributeBwdpausedatapoints(self._context)
        self.PhaseDataGroupId = RootLuSpecInstanceAttributePhasedatagroupid(self._context)
        self.FwdPauseDatapoints = RootLuSpecInstanceAttributeFwdpausedatapoints(self._context)
        self.SpecMapConfigurationBlobVec = RootLuSpecInstanceAttributeSpecmapconfigurationblobvec(self._context)
        self.XYMoveSpeed = RootLuSpecInstanceAttributeXymovespeed(self._context)
        self.RepetitionMode = RootLuSpecInstanceAttributeRepetitionmode(self._context)
        self.BwdMoveSpeed = RootLuSpecInstanceAttributeBwdmovespeed(self._context)
        self.BwdModRange = RootLuSpecInstanceAttributeBwdmodrange(self._context)
        self.SpecMapMode = RootLuSpecInstanceAttributeSpecmapmode(self._context)
        self.SpecEndMode = RootLuSpecInstanceAttributeSpecendmode(self._context)
        self.DeflectionForceOffset = RootLuSpecInstanceAttributeDeflectionforceoffset(self._context)
        self.FwdModRange = RootLuSpecInstanceAttributeFwdmodrange(self._context)
        self.StartOffset = RootLuSpecInstanceAttributeStartoffset(self._context)
        self.RepetitionCount = RootLuSpecInstanceAttributeRepetitioncount(self._context)
        self.PhaseSampleMask = RootLuSpecInstanceAttributePhasesamplemask(self._context)
        self.PhaseFwdPauseRate = RootLuSpecInstanceAttributePhasefwdpauserate(self._context)
        self.ModulationOutput = RootLuSpecInstanceAttributeModulationoutput(self._context)
        self.FwdModTime = RootLuSpecInstanceAttributeFwdmodtime(self._context)
        self.FwdMoveSpeed = RootLuSpecInstanceAttributeFwdmovespeed(self._context)
        self.FeedbackActive = RootLuSpecInstanceAttributeFeedbackactive(self._context)
        self.BwdPauseMode = RootLuSpecInstanceAttributeBwdpausemode(self._context)


class RootLuSpecInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance.Trigger'

    def ResumeNextPoint(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Trigger.ResumeNextPoint', *args)

    def ResumeLastPoint(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Trigger.ResumeLastPoint', *args)

    def Pause(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Trigger.Pause', *args)

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Trigger.Start', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.Spec.Instance.Trigger.UserAbort', *args)


class RootLuSpecInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Spec.Instance'
        self.Trigger = RootLuSpecInstanceTrigger(self._context)
        self.Attribute = RootLuSpecInstanceAttribute(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 RootLuSignalanalyzerInstance2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Busy'


class RootLuSignalanalyzerInstance2AttributeAmplitudemodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeModulation.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentphasebinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhaseBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentybinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentYBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeAmplitudectrligain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlIGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeAmplitudectrlpgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlPGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeHarmonicsource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.HarmonicSource.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentamplitudectrlsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlSetPoint.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.Input.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributePllunlocked(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PLLUnlocked.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributePhasectrligain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlIGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeReferenceamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeReferencephase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferencePhase.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeResetflagpllunlocked(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ResetFlagPLLUnlocked.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrenty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentY.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeTargetamplitudectrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlMode.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeTargetamplitudectrlsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.TargetAmplitudeCtrlSetPoint.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentxbinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentXBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeDisplaydfrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DisplayDfRange.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributePhasectrlpgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseCtrlPGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeLockincalcamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeAmplitudectrlsetpointcalibresult(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.AmplitudeCtrlSetPointCalibResult.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeOperatingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.OperatingMode.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentPhase.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeReferencefrequency(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceFrequency.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentctrlamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributePhaselockrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.PhaseLockRange.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeDemodulatorbw(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DemodulatorBW.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeReferencesource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceSource.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeReferenceamplitudefactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.ReferenceAmplitudeFactor.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentX.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeEnabledcblock(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.EnableDcBlock.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeDelaycomp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.DelayComp.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeLockincalcphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.LockInCalcPhase.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentamplitudectrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeCtrlMode.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentctrldeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentCtrlDeltaF.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentreferenceamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentReferenceAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance2AttributeCurrentamplitudebinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Attribute.CurrentAmplitudeBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Attribute'
        self.CurrentAmplitudeBinary = RootLuSignalanalyzerInstance2AttributeCurrentamplitudebinary(self._context)
        self.CurrentReferenceAmplitude = RootLuSignalanalyzerInstance2AttributeCurrentreferenceamplitude(self._context)
        self.CurrentCtrlDeltaF = RootLuSignalanalyzerInstance2AttributeCurrentctrldeltaf(self._context)
        self.CurrentAmplitudeCtrlMode = RootLuSignalanalyzerInstance2AttributeCurrentamplitudectrlmode(self._context)
        self.LockInCalcPhase = RootLuSignalanalyzerInstance2AttributeLockincalcphase(self._context)
        self.DelayComp = RootLuSignalanalyzerInstance2AttributeDelaycomp(self._context)
        self.EnableDcBlock = RootLuSignalanalyzerInstance2AttributeEnabledcblock(self._context)
        self.CurrentX = RootLuSignalanalyzerInstance2AttributeCurrentx(self._context)
        self.ReferenceAmplitudeFactor = RootLuSignalanalyzerInstance2AttributeReferenceamplitudefactor(self._context)
        self.ReferenceSource = RootLuSignalanalyzerInstance2AttributeReferencesource(self._context)
        self.DemodulatorBW = RootLuSignalanalyzerInstance2AttributeDemodulatorbw(self._context)
        self.PhaseLockRange = RootLuSignalanalyzerInstance2AttributePhaselockrange(self._context)
        self.CurrentCtrlAmplitude = RootLuSignalanalyzerInstance2AttributeCurrentctrlamplitude(self._context)
        self.ReferenceFrequency = RootLuSignalanalyzerInstance2AttributeReferencefrequency(self._context)
        self.CurrentPhase = RootLuSignalanalyzerInstance2AttributeCurrentphase(self._context)
        self.OperatingMode = RootLuSignalanalyzerInstance2AttributeOperatingmode(self._context)
        self.AmplitudeCtrlSetPointCalibResult = RootLuSignalanalyzerInstance2AttributeAmplitudectrlsetpointcalibresult(self._context)
        self.LockInCalcAmplitude = RootLuSignalanalyzerInstance2AttributeLockincalcamplitude(self._context)
        self.CurrentAmplitude = RootLuSignalanalyzerInstance2AttributeCurrentamplitude(self._context)
        self.PhaseCtrlPGain = RootLuSignalanalyzerInstance2AttributePhasectrlpgain(self._context)
        self.DisplayDfRange = RootLuSignalanalyzerInstance2AttributeDisplaydfrange(self._context)
        self.CurrentXBinary = RootLuSignalanalyzerInstance2AttributeCurrentxbinary(self._context)
        self.TargetAmplitudeCtrlSetPoint = RootLuSignalanalyzerInstance2AttributeTargetamplitudectrlsetpoint(self._context)
        self.TargetAmplitudeCtrlMode = RootLuSignalanalyzerInstance2AttributeTargetamplitudectrlmode(self._context)
        self.CurrentY = RootLuSignalanalyzerInstance2AttributeCurrenty(self._context)
        self.ResetFlagPLLUnlocked = RootLuSignalanalyzerInstance2AttributeResetflagpllunlocked(self._context)
        self.ReferencePhase = RootLuSignalanalyzerInstance2AttributeReferencephase(self._context)
        self.ReferenceAmplitude = RootLuSignalanalyzerInstance2AttributeReferenceamplitude(self._context)
        self.PhaseCtrlIGain = RootLuSignalanalyzerInstance2AttributePhasectrligain(self._context)
        self.PLLUnlocked = RootLuSignalanalyzerInstance2AttributePllunlocked(self._context)
        self.Input = RootLuSignalanalyzerInstance2AttributeInput(self._context)
        self.CurrentAmplitudeCtrlSetPoint = RootLuSignalanalyzerInstance2AttributeCurrentamplitudectrlsetpoint(self._context)
        self.HarmonicSource = RootLuSignalanalyzerInstance2AttributeHarmonicsource(self._context)
        self.AmplitudeCtrlPGain = RootLuSignalanalyzerInstance2AttributeAmplitudectrlpgain(self._context)
        self.AmplitudeCtrlIGain = RootLuSignalanalyzerInstance2AttributeAmplitudectrligain(self._context)
        self.CurrentYBinary = RootLuSignalanalyzerInstance2AttributeCurrentybinary(self._context)
        self.CurrentPhaseBinary = RootLuSignalanalyzerInstance2AttributeCurrentphasebinary(self._context)
        self.AmplitudeModulation = RootLuSignalanalyzerInstance2AttributeAmplitudemodulation(self._context)


class RootLuSignalanalyzerInstance2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2.Trigger'

    def StartPhaseZeroCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.StartPhaseZeroCalibration', *args)

    def StartUpdateCurrentFreeAmplitude(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.StartUpdateCurrentFreeAmplitude', *args)

    def StartSwitchToTargetAmplitudeCtrlMode(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.StartSwitchToTargetAmplitudeCtrlMode', *args)

    def StartKPFMPhaseCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.StartKPFMPhaseCalibration', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.UserAbort', *args)

    def SwitchToTargetAmplitudeCtrlMode(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.SwitchToTargetAmplitudeCtrlMode', *args)

    def StartSwitchToTargetAmplitudeCtrlSetPoint(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.StartSwitchToTargetAmplitudeCtrlSetPoint', *args)

    def SwitchToTargetAmplitudeCtrlSetPoint(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.SwitchToTargetAmplitudeCtrlSetPoint', *args)

    def KPFMPhaseCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance2.Trigger.KPFMPhaseCalibration', *args)


class RootLuSignalanalyzerInstance2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance2'
        self.Trigger = RootLuSignalanalyzerInstance2Trigger(self._context)
        self.Attribute = RootLuSignalanalyzerInstance2Attribute(self._context)
        self.Busy = RootLuSignalanalyzerInstance2Busy(self._context)


class RootLuSignalanalyzerInstance1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Busy'


class RootLuSignalanalyzerInstance1AttributeAmplitudemodulation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeModulation.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentphasebinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhaseBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentybinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentYBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeAmplitudectrligain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlIGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeAmplitudectrlpgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlPGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeHarmonicsource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.HarmonicSource.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentamplitudectrlsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlSetPoint.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeInput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.Input.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributePllunlocked(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PLLUnlocked.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributePhasectrligain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlIGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeReferenceamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeReferencephase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferencePhase.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeResetflagpllunlocked(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ResetFlagPLLUnlocked.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrenty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentY.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeTargetamplitudectrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlMode.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeTargetamplitudectrlsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.TargetAmplitudeCtrlSetPoint.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentxbinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentXBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeDisplaydfrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DisplayDfRange.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributePhasectrlpgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseCtrlPGain.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeLockincalcamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeAmplitudectrlsetpointcalibresult(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.AmplitudeCtrlSetPointCalibResult.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeOperatingmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.OperatingMode.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentPhase.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeReferencefrequency(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceFrequency.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentctrlamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributePhaselockrange(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.PhaseLockRange.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeDemodulatorbw(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DemodulatorBW.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeReferencesource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceSource.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeReferenceamplitudefactor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.ReferenceAmplitudeFactor.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentX.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeEnabledcblock(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.EnableDcBlock.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeDelaycomp(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.DelayComp.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeLockincalcphase(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.LockInCalcPhase.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentamplitudectrlmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeCtrlMode.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentctrldeltaf(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentCtrlDeltaF.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentreferenceamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentReferenceAmplitude.SetVectorString', *args)


class RootLuSignalanalyzerInstance1AttributeCurrentamplitudebinary(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Attribute.CurrentAmplitudeBinary.SetVectorString', *args)


class RootLuSignalanalyzerInstance1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Attribute'
        self.CurrentAmplitudeBinary = RootLuSignalanalyzerInstance1AttributeCurrentamplitudebinary(self._context)
        self.CurrentReferenceAmplitude = RootLuSignalanalyzerInstance1AttributeCurrentreferenceamplitude(self._context)
        self.CurrentCtrlDeltaF = RootLuSignalanalyzerInstance1AttributeCurrentctrldeltaf(self._context)
        self.CurrentAmplitudeCtrlMode = RootLuSignalanalyzerInstance1AttributeCurrentamplitudectrlmode(self._context)
        self.LockInCalcPhase = RootLuSignalanalyzerInstance1AttributeLockincalcphase(self._context)
        self.DelayComp = RootLuSignalanalyzerInstance1AttributeDelaycomp(self._context)
        self.EnableDcBlock = RootLuSignalanalyzerInstance1AttributeEnabledcblock(self._context)
        self.CurrentX = RootLuSignalanalyzerInstance1AttributeCurrentx(self._context)
        self.ReferenceAmplitudeFactor = RootLuSignalanalyzerInstance1AttributeReferenceamplitudefactor(self._context)
        self.ReferenceSource = RootLuSignalanalyzerInstance1AttributeReferencesource(self._context)
        self.DemodulatorBW = RootLuSignalanalyzerInstance1AttributeDemodulatorbw(self._context)
        self.PhaseLockRange = RootLuSignalanalyzerInstance1AttributePhaselockrange(self._context)
        self.CurrentCtrlAmplitude = RootLuSignalanalyzerInstance1AttributeCurrentctrlamplitude(self._context)
        self.ReferenceFrequency = RootLuSignalanalyzerInstance1AttributeReferencefrequency(self._context)
        self.CurrentPhase = RootLuSignalanalyzerInstance1AttributeCurrentphase(self._context)
        self.OperatingMode = RootLuSignalanalyzerInstance1AttributeOperatingmode(self._context)
        self.AmplitudeCtrlSetPointCalibResult = RootLuSignalanalyzerInstance1AttributeAmplitudectrlsetpointcalibresult(self._context)
        self.LockInCalcAmplitude = RootLuSignalanalyzerInstance1AttributeLockincalcamplitude(self._context)
        self.CurrentAmplitude = RootLuSignalanalyzerInstance1AttributeCurrentamplitude(self._context)
        self.PhaseCtrlPGain = RootLuSignalanalyzerInstance1AttributePhasectrlpgain(self._context)
        self.DisplayDfRange = RootLuSignalanalyzerInstance1AttributeDisplaydfrange(self._context)
        self.CurrentXBinary = RootLuSignalanalyzerInstance1AttributeCurrentxbinary(self._context)
        self.TargetAmplitudeCtrlSetPoint = RootLuSignalanalyzerInstance1AttributeTargetamplitudectrlsetpoint(self._context)
        self.TargetAmplitudeCtrlMode = RootLuSignalanalyzerInstance1AttributeTargetamplitudectrlmode(self._context)
        self.CurrentY = RootLuSignalanalyzerInstance1AttributeCurrenty(self._context)
        self.ResetFlagPLLUnlocked = RootLuSignalanalyzerInstance1AttributeResetflagpllunlocked(self._context)
        self.ReferencePhase = RootLuSignalanalyzerInstance1AttributeReferencephase(self._context)
        self.ReferenceAmplitude = RootLuSignalanalyzerInstance1AttributeReferenceamplitude(self._context)
        self.PhaseCtrlIGain = RootLuSignalanalyzerInstance1AttributePhasectrligain(self._context)
        self.PLLUnlocked = RootLuSignalanalyzerInstance1AttributePllunlocked(self._context)
        self.Input = RootLuSignalanalyzerInstance1AttributeInput(self._context)
        self.CurrentAmplitudeCtrlSetPoint = RootLuSignalanalyzerInstance1AttributeCurrentamplitudectrlsetpoint(self._context)
        self.HarmonicSource = RootLuSignalanalyzerInstance1AttributeHarmonicsource(self._context)
        self.AmplitudeCtrlPGain = RootLuSignalanalyzerInstance1AttributeAmplitudectrlpgain(self._context)
        self.AmplitudeCtrlIGain = RootLuSignalanalyzerInstance1AttributeAmplitudectrligain(self._context)
        self.CurrentYBinary = RootLuSignalanalyzerInstance1AttributeCurrentybinary(self._context)
        self.CurrentPhaseBinary = RootLuSignalanalyzerInstance1AttributeCurrentphasebinary(self._context)
        self.AmplitudeModulation = RootLuSignalanalyzerInstance1AttributeAmplitudemodulation(self._context)


class RootLuSignalanalyzerInstance1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1.Trigger'

    def StartPhaseZeroCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.StartPhaseZeroCalibration', *args)

    def StartUpdateCurrentFreeAmplitude(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.StartUpdateCurrentFreeAmplitude', *args)

    def StartSwitchToTargetAmplitudeCtrlMode(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.StartSwitchToTargetAmplitudeCtrlMode', *args)

    def StartKPFMPhaseCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.StartKPFMPhaseCalibration', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.UserAbort', *args)

    def SwitchToTargetAmplitudeCtrlMode(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.SwitchToTargetAmplitudeCtrlMode', *args)

    def StartSwitchToTargetAmplitudeCtrlSetPoint(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.StartSwitchToTargetAmplitudeCtrlSetPoint', *args)

    def SwitchToTargetAmplitudeCtrlSetPoint(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.SwitchToTargetAmplitudeCtrlSetPoint', *args)

    def KPFMPhaseCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SignalAnalyzer.Instance1.Trigger.KPFMPhaseCalibration', *args)


class RootLuSignalanalyzerInstance1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer.Instance1'
        self.Trigger = RootLuSignalanalyzerInstance1Trigger(self._context)
        self.Attribute = RootLuSignalanalyzerInstance1Attribute(self._context)
        self.Busy = RootLuSignalanalyzerInstance1Busy(self._context)


class RootLuSignalanalyzer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SignalAnalyzer'
        self.Instance1 = RootLuSignalanalyzerInstance1(self._context)
        self.Instance2 = RootLuSignalanalyzerInstance2(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 RootLuRescanInstanceAttributeEnable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Rescan.Instance.Attribute.Enable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.Enable.SetVectorString', *args)


class RootLuRescanInstanceAttributeLinerepetitioncount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Rescan.Instance.Attribute.LineRepetitionCount'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionCount.SetVectorString', *args)


class RootLuRescanInstanceAttributeLinerepetitionmaxcount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMaxCount.SetVectorString', *args)


class RootLuRescanInstanceAttributeLinerepetitionmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Rescan.Instance.Attribute.LineRepetitionMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Rescan.Instance.Attribute.LineRepetitionMax.SetVectorString', *args)


class RootLuRescanInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Rescan.Instance.Attribute'
        self.LineRepetitionMax = RootLuRescanInstanceAttributeLinerepetitionmax(self._context)
        self.LineRepetitionMaxCount = RootLuRescanInstanceAttributeLinerepetitionmaxcount(self._context)
        self.LineRepetitionCount = RootLuRescanInstanceAttributeLinerepetitioncount(self._context)
        self.Enable = RootLuRescanInstanceAttributeEnable(self._context)


class RootLuRescanInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Rescan.Instance.Trigger'


class RootLuRescanInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Rescan.Instance'
        self.Trigger = RootLuRescanInstanceTrigger(self._context)
        self.Attribute = RootLuRescanInstanceAttribute(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 RootLuHvamplifierInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Busy'


class RootLuHvamplifierInstanceAttributeTemperature(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.Temperature'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Temperature.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeLastmodeswitchretval(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.LastModeSwitchRetval.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeModetarget(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.ModeTarget'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeTarget.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeOutputdischargedelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.OutputDischargeDelay.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeHvmoduleenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.HvModuleEnabled.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeZmodulationenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ZModulationEnabled.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeType(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.Type'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.Type.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeInterlockopenuser(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenUser.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributePowerenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.PowerEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.PowerEnabled.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeInterlockopencxcable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenCxCable.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeInterlockopenhvcable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.InterlockOpenHvCable.SetVectorString', *args)


class RootLuHvamplifierInstanceAttributeModecurrent(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute.ModeCurrent'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Attribute.ModeCurrent.SetVectorString', *args)


class RootLuHvamplifierInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Attribute'
        self.ModeCurrent = RootLuHvamplifierInstanceAttributeModecurrent(self._context)
        self.InterlockOpenHvCable = RootLuHvamplifierInstanceAttributeInterlockopenhvcable(self._context)
        self.InterlockOpenCxCable = RootLuHvamplifierInstanceAttributeInterlockopencxcable(self._context)
        self.PowerEnabled = RootLuHvamplifierInstanceAttributePowerenabled(self._context)
        self.InterlockOpenUser = RootLuHvamplifierInstanceAttributeInterlockopenuser(self._context)
        self.Type = RootLuHvamplifierInstanceAttributeType(self._context)
        self.ZModulationEnabled = RootLuHvamplifierInstanceAttributeZmodulationenabled(self._context)
        self.HvModuleEnabled = RootLuHvamplifierInstanceAttributeHvmoduleenabled(self._context)
        self.OutputDischargeDelay = RootLuHvamplifierInstanceAttributeOutputdischargedelay(self._context)
        self.ModeTarget = RootLuHvamplifierInstanceAttributeModetarget(self._context)
        self.LastModeSwitchRetval = RootLuHvamplifierInstanceAttributeLastmodeswitchretval(self._context)
        self.Temperature = RootLuHvamplifierInstanceAttributeTemperature(self._context)


class RootLuHvamplifierInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance.Trigger'

    def SwitchToTargetMode(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.SwitchToTargetMode', *args)

    def DisablePower(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.DisablePower', *args)

    def Depreciated_6(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.Depreciated_6', *args)

    def DisableZModulation(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.DisableZModulation', *args)

    def StartSwitchToTargetMode(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.StartSwitchToTargetMode', *args)

    def EnableModule(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.EnableModule', *args)

    def EnableZModulation(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.EnableZModulation', *args)

    def DisableModule(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.DisableModule', *args)

    def EnablePower(self, *args) -> Any:
        return self._context.call('root.lu.HVAmplifier.Instance.Trigger.EnablePower', *args)


class RootLuHvamplifierInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier.Instance'
        self.Trigger = RootLuHvamplifierInstanceTrigger(self._context)
        self.Attribute = RootLuHvamplifierInstanceAttribute(self._context)
        self.Busy = RootLuHvamplifierInstanceBusy(self._context)


class RootLuHvamplifier(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.HVAmplifier'
        self.Instance = RootLuHvamplifierInstance(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 RootLuTestInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Test.Instance.Attribute'


class RootLuTestInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Test.Instance.Trigger'

    def ForceAllDACToMax(self, *args) -> Any:
        return self._context.call('root.lu.Test.Instance.Trigger.ForceAllDACToMax', *args)

    def ForceAllDACToZero(self, *args) -> Any:
        return self._context.call('root.lu.Test.Instance.Trigger.ForceAllDACToZero', *args)

    def ForceAllDACToMin(self, *args) -> Any:
        return self._context.call('root.lu.Test.Instance.Trigger.ForceAllDACToMin', *args)


class RootLuTestInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Test.Instance'
        self.Trigger = RootLuTestInstanceTrigger(self._context)
        self.Attribute = RootLuTestInstanceAttribute(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 RootLuApproachInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Busy'


class RootLuApproachInstanceAttributeApproachresult(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.ApproachResult'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachResult.SetVectorString', *args)


class RootLuApproachInstanceAttributeReleasetip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.ReleaseTip'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ReleaseTip.SetVectorString', *args)


class RootLuApproachInstanceAttributeCurrentzstagepos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.CurrentZStagePos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.CurrentZStagePos.SetVectorString', *args)


class RootLuApproachInstanceAttributeApproachsteps(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.ApproachSteps'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSteps.SetVectorString', *args)


class RootLuApproachInstanceAttributeApproachstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.ApproachStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachStatus.SetVectorString', *args)


class RootLuApproachInstanceAttributeApproachpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.ApproachPos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPos.SetVectorString', *args)


class RootLuApproachInstanceAttributeMotorsource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.MotorSource'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.MotorSource.SetVectorString', *args)


class RootLuApproachInstanceAttributeStepbysteptime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.StepByStepTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepTime.SetVectorString', *args)


class RootLuApproachInstanceAttributeStepbystepfinestepsizepercentage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepFineStepSizePercentage.SetVectorString', *args)


class RootLuApproachInstanceAttributeWithdrawsteps(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.WithdrawSteps'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.WithdrawSteps.SetVectorString', *args)


class RootLuApproachInstanceAttributeApproachspeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.ApproachSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachSpeed.SetVectorString', *args)


class RootLuApproachInstanceAttributeStepperdirection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.StepperDirection'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepperDirection.SetVectorString', *args)


class RootLuApproachInstanceAttributeApproachposerror(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.ApproachPosError'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.ApproachPosError.SetVectorString', *args)


class RootLuApproachInstanceAttributeStepbystepslope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.StepByStepSlope'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepSlope.SetVectorString', *args)


class RootLuApproachInstanceAttributeEnablepreapproachxyclcalibration(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.EnablePreApproachXYCLCalibration.SetVectorString', *args)


class RootLuApproachInstanceAttributeStepbystepmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.StepByStepMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepMode.SetVectorString', *args)


class RootLuApproachInstanceAttributeStepperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.StepPeriod'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepPeriod.SetVectorString', *args)


class RootLuApproachInstanceAttributeAfmapproachmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.AFMApproachMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.AFMApproachMode.SetVectorString', *args)


class RootLuApproachInstanceAttributeStepbystepcoarsstepsizepercentage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.StepByStepCoarsStepSizePercentage.SetVectorString', *args)


class RootLuApproachInstanceAttributeRetracttip(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute.RetractTip'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Attribute.RetractTip.SetVectorString', *args)


class RootLuApproachInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Attribute'
        self.RetractTip = RootLuApproachInstanceAttributeRetracttip(self._context)
        self.StepByStepCoarsStepSizePercentage = RootLuApproachInstanceAttributeStepbystepcoarsstepsizepercentage(self._context)
        self.AFMApproachMode = RootLuApproachInstanceAttributeAfmapproachmode(self._context)
        self.StepPeriod = RootLuApproachInstanceAttributeStepperiod(self._context)
        self.StepByStepMode = RootLuApproachInstanceAttributeStepbystepmode(self._context)
        self.EnablePreApproachXYCLCalibration = RootLuApproachInstanceAttributeEnablepreapproachxyclcalibration(self._context)
        self.StepByStepSlope = RootLuApproachInstanceAttributeStepbystepslope(self._context)
        self.ApproachPosError = RootLuApproachInstanceAttributeApproachposerror(self._context)
        self.StepperDirection = RootLuApproachInstanceAttributeStepperdirection(self._context)
        self.ApproachSpeed = RootLuApproachInstanceAttributeApproachspeed(self._context)
        self.WithdrawSteps = RootLuApproachInstanceAttributeWithdrawsteps(self._context)
        self.StepByStepFineStepSizePercentage = RootLuApproachInstanceAttributeStepbystepfinestepsizepercentage(self._context)
        self.StepByStepTime = RootLuApproachInstanceAttributeStepbysteptime(self._context)
        self.MotorSource = RootLuApproachInstanceAttributeMotorsource(self._context)
        self.ApproachPos = RootLuApproachInstanceAttributeApproachpos(self._context)
        self.ApproachStatus = RootLuApproachInstanceAttributeApproachstatus(self._context)
        self.ApproachSteps = RootLuApproachInstanceAttributeApproachsteps(self._context)
        self.CurrentZStagePos = RootLuApproachInstanceAttributeCurrentzstagepos(self._context)
        self.ReleaseTip = RootLuApproachInstanceAttributeReleasetip(self._context)
        self.ApproachResult = RootLuApproachInstanceAttributeApproachresult(self._context)


class RootLuApproachInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance.Trigger'

    def StartPreApproach(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Trigger.StartPreApproach', *args)

    def StartApproachMotor(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Trigger.StartApproachMotor', *args)

    def StartApproachSteps(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Trigger.StartApproachSteps', *args)

    def StartApproachAFM(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Trigger.StartApproachAFM', *args)

    def UserDone(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Trigger.UserDone', *args)

    def StartAdjustTipPos(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Trigger.StartAdjustTipPos', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.Approach.Instance.Trigger.UserAbort', *args)


class RootLuApproachInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Approach.Instance'
        self.Trigger = RootLuApproachInstanceTrigger(self._context)
        self.Attribute = RootLuApproachInstanceAttribute(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 RootLuPidcontrollerPiduser2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Busy'


class RootLuPidcontrollerPiduser2AttributeIgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.IGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.IGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeInputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.InputSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputSetPoint.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeInputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.InputActual'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.InputActual.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeEnablemedianfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMedianFilter.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.MaxValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MaxValue.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.MinValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.MinValue.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributePgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.PGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.PGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.ReachedErrLim'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedErrLim.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.ReachedMin'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMin.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.Slope'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Slope.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Polarity.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeSelectoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.SelectOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SelectOutput.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.Offset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.Offset.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeSetpointmodulationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointModulationEnable.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.ReachedMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ReachedMax.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeDgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.DGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.DGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeFeedbackmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.FeedbackMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.FeedbackMode.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeComparemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.CompareMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.CompareMode.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeEnablememorysignalgenposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenPosition.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.ErrorLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.ErrorLimit.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeSetpointgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.SetPointGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.SetPointGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser2AttributeEnablememorysignalgendrive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Attribute.EnableMemorySignalGenDrive.SetVectorString', *args)


class RootLuPidcontrollerPiduser2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Attribute'
        self.EnableMemorySignalGenDrive = RootLuPidcontrollerPiduser2AttributeEnablememorysignalgendrive(self._context)
        self.SetPointGain = RootLuPidcontrollerPiduser2AttributeSetpointgain(self._context)
        self.ErrorLimit = RootLuPidcontrollerPiduser2AttributeErrorlimit(self._context)
        self.EnableMemorySignalGenPosition = RootLuPidcontrollerPiduser2AttributeEnablememorysignalgenposition(self._context)
        self.CompareMode = RootLuPidcontrollerPiduser2AttributeComparemode(self._context)
        self.FeedbackMode = RootLuPidcontrollerPiduser2AttributeFeedbackmode(self._context)
        self.DGain = RootLuPidcontrollerPiduser2AttributeDgain(self._context)
        self.ReachedMax = RootLuPidcontrollerPiduser2AttributeReachedmax(self._context)
        self.SetPointModulationEnable = RootLuPidcontrollerPiduser2AttributeSetpointmodulationenable(self._context)
        self.Offset = RootLuPidcontrollerPiduser2AttributeOffset(self._context)
        self.SelectOutput = RootLuPidcontrollerPiduser2AttributeSelectoutput(self._context)
        self.Polarity = RootLuPidcontrollerPiduser2AttributePolarity(self._context)
        self.Slope = RootLuPidcontrollerPiduser2AttributeSlope(self._context)
        self.ReachedMin = RootLuPidcontrollerPiduser2AttributeReachedmin(self._context)
        self.ReachedErrLim = RootLuPidcontrollerPiduser2AttributeReachederrlim(self._context)
        self.PGain = RootLuPidcontrollerPiduser2AttributePgain(self._context)
        self.MinValue = RootLuPidcontrollerPiduser2AttributeMinvalue(self._context)
        self.MaxValue = RootLuPidcontrollerPiduser2AttributeMaxvalue(self._context)
        self.EnableMedianFilter = RootLuPidcontrollerPiduser2AttributeEnablemedianfilter(self._context)
        self.InputActual = RootLuPidcontrollerPiduser2AttributeInputactual(self._context)
        self.InputSetPoint = RootLuPidcontrollerPiduser2AttributeInputsetpoint(self._context)
        self.IGain = RootLuPidcontrollerPiduser2AttributeIgain(self._context)


class RootLuPidcontrollerPiduser2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2.Trigger'

    def ClearPIDAccu(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser2.Trigger.ClearPIDAccu', *args)


class RootLuPidcontrollerPiduser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser2'
        self.Trigger = RootLuPidcontrollerPiduser2Trigger(self._context)
        self.Attribute = RootLuPidcontrollerPiduser2Attribute(self._context)
        self.Busy = RootLuPidcontrollerPiduser2Busy(self._context)


class RootLuPidcontrollerPidyBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Busy'


class RootLuPidcontrollerPidyAttributeIgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.IGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.IGain.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeInputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.InputSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputSetPoint.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeInputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.InputActual'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.InputActual.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeEnablemedianfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.EnableMedianFilter'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMedianFilter.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.MaxValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MaxValue.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.MinValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.MinValue.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributePgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.PGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.PGain.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.ReachedErrLim'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedErrLim.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.ReachedMin'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMin.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.Slope'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Slope.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Polarity.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeSelectoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.SelectOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SelectOutput.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.Offset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.Offset.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeSetpointmodulationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.SetPointModulationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointModulationEnable.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.ReachedMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ReachedMax.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeDgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.DGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.DGain.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeFeedbackmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.FeedbackMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.FeedbackMode.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeComparemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.CompareMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.CompareMode.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeEnablememorysignalgenposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenPosition.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.ErrorLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.ErrorLimit.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeSetpointgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.SetPointGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.SetPointGain.SetVectorString', *args)


class RootLuPidcontrollerPidyAttributeEnablememorysignalgendrive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Attribute.EnableMemorySignalGenDrive.SetVectorString', *args)


class RootLuPidcontrollerPidyAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Attribute'
        self.EnableMemorySignalGenDrive = RootLuPidcontrollerPidyAttributeEnablememorysignalgendrive(self._context)
        self.SetPointGain = RootLuPidcontrollerPidyAttributeSetpointgain(self._context)
        self.ErrorLimit = RootLuPidcontrollerPidyAttributeErrorlimit(self._context)
        self.EnableMemorySignalGenPosition = RootLuPidcontrollerPidyAttributeEnablememorysignalgenposition(self._context)
        self.CompareMode = RootLuPidcontrollerPidyAttributeComparemode(self._context)
        self.FeedbackMode = RootLuPidcontrollerPidyAttributeFeedbackmode(self._context)
        self.DGain = RootLuPidcontrollerPidyAttributeDgain(self._context)
        self.ReachedMax = RootLuPidcontrollerPidyAttributeReachedmax(self._context)
        self.SetPointModulationEnable = RootLuPidcontrollerPidyAttributeSetpointmodulationenable(self._context)
        self.Offset = RootLuPidcontrollerPidyAttributeOffset(self._context)
        self.SelectOutput = RootLuPidcontrollerPidyAttributeSelectoutput(self._context)
        self.Polarity = RootLuPidcontrollerPidyAttributePolarity(self._context)
        self.Slope = RootLuPidcontrollerPidyAttributeSlope(self._context)
        self.ReachedMin = RootLuPidcontrollerPidyAttributeReachedmin(self._context)
        self.ReachedErrLim = RootLuPidcontrollerPidyAttributeReachederrlim(self._context)
        self.PGain = RootLuPidcontrollerPidyAttributePgain(self._context)
        self.MinValue = RootLuPidcontrollerPidyAttributeMinvalue(self._context)
        self.MaxValue = RootLuPidcontrollerPidyAttributeMaxvalue(self._context)
        self.EnableMedianFilter = RootLuPidcontrollerPidyAttributeEnablemedianfilter(self._context)
        self.InputActual = RootLuPidcontrollerPidyAttributeInputactual(self._context)
        self.InputSetPoint = RootLuPidcontrollerPidyAttributeInputsetpoint(self._context)
        self.IGain = RootLuPidcontrollerPidyAttributeIgain(self._context)


class RootLuPidcontrollerPidyTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY.Trigger'

    def ClearPIDAccu(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidY.Trigger.ClearPIDAccu', *args)


class RootLuPidcontrollerPidy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidY'
        self.Trigger = RootLuPidcontrollerPidyTrigger(self._context)
        self.Attribute = RootLuPidcontrollerPidyAttribute(self._context)
        self.Busy = RootLuPidcontrollerPidyBusy(self._context)


class RootLuPidcontrollerPidwBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Busy'


class RootLuPidcontrollerPidwAttributeIgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.IGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.IGain.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeInputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.InputSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputSetPoint.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeInputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.InputActual'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.InputActual.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeEnablemedianfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.EnableMedianFilter'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMedianFilter.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.MaxValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MaxValue.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.MinValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.MinValue.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributePgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.PGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.PGain.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.ReachedErrLim'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedErrLim.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.ReachedMin'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMin.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.Slope'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Slope.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Polarity.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeSelectoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.SelectOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SelectOutput.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.Offset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.Offset.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeSetpointmodulationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.SetPointModulationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointModulationEnable.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.ReachedMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ReachedMax.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeDgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.DGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.DGain.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeFeedbackmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.FeedbackMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.FeedbackMode.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeComparemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.CompareMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.CompareMode.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeEnablememorysignalgenposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenPosition.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.ErrorLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.ErrorLimit.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeSetpointgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.SetPointGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.SetPointGain.SetVectorString', *args)


class RootLuPidcontrollerPidwAttributeEnablememorysignalgendrive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Attribute.EnableMemorySignalGenDrive.SetVectorString', *args)


class RootLuPidcontrollerPidwAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Attribute'
        self.EnableMemorySignalGenDrive = RootLuPidcontrollerPidwAttributeEnablememorysignalgendrive(self._context)
        self.SetPointGain = RootLuPidcontrollerPidwAttributeSetpointgain(self._context)
        self.ErrorLimit = RootLuPidcontrollerPidwAttributeErrorlimit(self._context)
        self.EnableMemorySignalGenPosition = RootLuPidcontrollerPidwAttributeEnablememorysignalgenposition(self._context)
        self.CompareMode = RootLuPidcontrollerPidwAttributeComparemode(self._context)
        self.FeedbackMode = RootLuPidcontrollerPidwAttributeFeedbackmode(self._context)
        self.DGain = RootLuPidcontrollerPidwAttributeDgain(self._context)
        self.ReachedMax = RootLuPidcontrollerPidwAttributeReachedmax(self._context)
        self.SetPointModulationEnable = RootLuPidcontrollerPidwAttributeSetpointmodulationenable(self._context)
        self.Offset = RootLuPidcontrollerPidwAttributeOffset(self._context)
        self.SelectOutput = RootLuPidcontrollerPidwAttributeSelectoutput(self._context)
        self.Polarity = RootLuPidcontrollerPidwAttributePolarity(self._context)
        self.Slope = RootLuPidcontrollerPidwAttributeSlope(self._context)
        self.ReachedMin = RootLuPidcontrollerPidwAttributeReachedmin(self._context)
        self.ReachedErrLim = RootLuPidcontrollerPidwAttributeReachederrlim(self._context)
        self.PGain = RootLuPidcontrollerPidwAttributePgain(self._context)
        self.MinValue = RootLuPidcontrollerPidwAttributeMinvalue(self._context)
        self.MaxValue = RootLuPidcontrollerPidwAttributeMaxvalue(self._context)
        self.EnableMedianFilter = RootLuPidcontrollerPidwAttributeEnablemedianfilter(self._context)
        self.InputActual = RootLuPidcontrollerPidwAttributeInputactual(self._context)
        self.InputSetPoint = RootLuPidcontrollerPidwAttributeInputsetpoint(self._context)
        self.IGain = RootLuPidcontrollerPidwAttributeIgain(self._context)


class RootLuPidcontrollerPidwTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW.Trigger'

    def ClearPIDAccu(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidW.Trigger.ClearPIDAccu', *args)


class RootLuPidcontrollerPidw(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidW'
        self.Trigger = RootLuPidcontrollerPidwTrigger(self._context)
        self.Attribute = RootLuPidcontrollerPidwAttribute(self._context)
        self.Busy = RootLuPidcontrollerPidwBusy(self._context)


class RootLuPidcontrollerPiduser1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Busy'


class RootLuPidcontrollerPiduser1AttributeIgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.IGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.IGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeInputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.InputSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputSetPoint.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeInputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.InputActual'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.InputActual.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeEnablemedianfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMedianFilter.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.MaxValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MaxValue.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.MinValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.MinValue.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributePgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.PGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.PGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.ReachedErrLim'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedErrLim.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.ReachedMin'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMin.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.Slope'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Slope.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Polarity.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeSelectoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.SelectOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SelectOutput.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.Offset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.Offset.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeSetpointmodulationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointModulationEnable.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.ReachedMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ReachedMax.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeDgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.DGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.DGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeFeedbackmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.FeedbackMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.FeedbackMode.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeComparemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.CompareMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.CompareMode.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeEnablememorysignalgenposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenPosition.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.ErrorLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.ErrorLimit.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeSetpointgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.SetPointGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.SetPointGain.SetVectorString', *args)


class RootLuPidcontrollerPiduser1AttributeEnablememorysignalgendrive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Attribute.EnableMemorySignalGenDrive.SetVectorString', *args)


class RootLuPidcontrollerPiduser1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Attribute'
        self.EnableMemorySignalGenDrive = RootLuPidcontrollerPiduser1AttributeEnablememorysignalgendrive(self._context)
        self.SetPointGain = RootLuPidcontrollerPiduser1AttributeSetpointgain(self._context)
        self.ErrorLimit = RootLuPidcontrollerPiduser1AttributeErrorlimit(self._context)
        self.EnableMemorySignalGenPosition = RootLuPidcontrollerPiduser1AttributeEnablememorysignalgenposition(self._context)
        self.CompareMode = RootLuPidcontrollerPiduser1AttributeComparemode(self._context)
        self.FeedbackMode = RootLuPidcontrollerPiduser1AttributeFeedbackmode(self._context)
        self.DGain = RootLuPidcontrollerPiduser1AttributeDgain(self._context)
        self.ReachedMax = RootLuPidcontrollerPiduser1AttributeReachedmax(self._context)
        self.SetPointModulationEnable = RootLuPidcontrollerPiduser1AttributeSetpointmodulationenable(self._context)
        self.Offset = RootLuPidcontrollerPiduser1AttributeOffset(self._context)
        self.SelectOutput = RootLuPidcontrollerPiduser1AttributeSelectoutput(self._context)
        self.Polarity = RootLuPidcontrollerPiduser1AttributePolarity(self._context)
        self.Slope = RootLuPidcontrollerPiduser1AttributeSlope(self._context)
        self.ReachedMin = RootLuPidcontrollerPiduser1AttributeReachedmin(self._context)
        self.ReachedErrLim = RootLuPidcontrollerPiduser1AttributeReachederrlim(self._context)
        self.PGain = RootLuPidcontrollerPiduser1AttributePgain(self._context)
        self.MinValue = RootLuPidcontrollerPiduser1AttributeMinvalue(self._context)
        self.MaxValue = RootLuPidcontrollerPiduser1AttributeMaxvalue(self._context)
        self.EnableMedianFilter = RootLuPidcontrollerPiduser1AttributeEnablemedianfilter(self._context)
        self.InputActual = RootLuPidcontrollerPiduser1AttributeInputactual(self._context)
        self.InputSetPoint = RootLuPidcontrollerPiduser1AttributeInputsetpoint(self._context)
        self.IGain = RootLuPidcontrollerPiduser1AttributeIgain(self._context)


class RootLuPidcontrollerPiduser1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1.Trigger'

    def ClearPIDAccu(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidUser1.Trigger.ClearPIDAccu', *args)


class RootLuPidcontrollerPiduser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidUser1'
        self.Trigger = RootLuPidcontrollerPiduser1Trigger(self._context)
        self.Attribute = RootLuPidcontrollerPiduser1Attribute(self._context)
        self.Busy = RootLuPidcontrollerPiduser1Busy(self._context)


class RootLuPidcontrollerPidxBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Busy'


class RootLuPidcontrollerPidxAttributeIgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.IGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.IGain.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeInputsetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.InputSetPoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputSetPoint.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeInputactual(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.InputActual'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.InputActual.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeEnablemedianfilter(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.EnableMedianFilter'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMedianFilter.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeMaxvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.MaxValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MaxValue.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.MinValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.MinValue.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributePgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.PGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.PGain.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeReachederrlim(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.ReachedErrLim'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedErrLim.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeReachedmin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.ReachedMin'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMin.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeSlope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.Slope'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Slope.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Polarity.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeSelectoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.SelectOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SelectOutput.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeOffset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.Offset'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.Offset.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeSetpointmodulationenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.SetPointModulationEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointModulationEnable.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeReachedmax(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.ReachedMax'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ReachedMax.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeDgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.DGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.DGain.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeFeedbackmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.FeedbackMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.FeedbackMode.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeComparemode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.CompareMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.CompareMode.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeEnablememorysignalgenposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenPosition.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeErrorlimit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.ErrorLimit'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.ErrorLimit.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeSetpointgain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.SetPointGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.SetPointGain.SetVectorString', *args)


class RootLuPidcontrollerPidxAttributeEnablememorysignalgendrive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Attribute.EnableMemorySignalGenDrive.SetVectorString', *args)


class RootLuPidcontrollerPidxAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Attribute'
        self.EnableMemorySignalGenDrive = RootLuPidcontrollerPidxAttributeEnablememorysignalgendrive(self._context)
        self.SetPointGain = RootLuPidcontrollerPidxAttributeSetpointgain(self._context)
        self.ErrorLimit = RootLuPidcontrollerPidxAttributeErrorlimit(self._context)
        self.EnableMemorySignalGenPosition = RootLuPidcontrollerPidxAttributeEnablememorysignalgenposition(self._context)
        self.CompareMode = RootLuPidcontrollerPidxAttributeComparemode(self._context)
        self.FeedbackMode = RootLuPidcontrollerPidxAttributeFeedbackmode(self._context)
        self.DGain = RootLuPidcontrollerPidxAttributeDgain(self._context)
        self.ReachedMax = RootLuPidcontrollerPidxAttributeReachedmax(self._context)
        self.SetPointModulationEnable = RootLuPidcontrollerPidxAttributeSetpointmodulationenable(self._context)
        self.Offset = RootLuPidcontrollerPidxAttributeOffset(self._context)
        self.SelectOutput = RootLuPidcontrollerPidxAttributeSelectoutput(self._context)
        self.Polarity = RootLuPidcontrollerPidxAttributePolarity(self._context)
        self.Slope = RootLuPidcontrollerPidxAttributeSlope(self._context)
        self.ReachedMin = RootLuPidcontrollerPidxAttributeReachedmin(self._context)
        self.ReachedErrLim = RootLuPidcontrollerPidxAttributeReachederrlim(self._context)
        self.PGain = RootLuPidcontrollerPidxAttributePgain(self._context)
        self.MinValue = RootLuPidcontrollerPidxAttributeMinvalue(self._context)
        self.MaxValue = RootLuPidcontrollerPidxAttributeMaxvalue(self._context)
        self.EnableMedianFilter = RootLuPidcontrollerPidxAttributeEnablemedianfilter(self._context)
        self.InputActual = RootLuPidcontrollerPidxAttributeInputactual(self._context)
        self.InputSetPoint = RootLuPidcontrollerPidxAttributeInputsetpoint(self._context)
        self.IGain = RootLuPidcontrollerPidxAttributeIgain(self._context)


class RootLuPidcontrollerPidxTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX.Trigger'

    def ClearPIDAccu(self, *args) -> Any:
        return self._context.call('root.lu.PIDController.PidX.Trigger.ClearPIDAccu', *args)


class RootLuPidcontrollerPidx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController.PidX'
        self.Trigger = RootLuPidcontrollerPidxTrigger(self._context)
        self.Attribute = RootLuPidcontrollerPidxAttribute(self._context)
        self.Busy = RootLuPidcontrollerPidxBusy(self._context)


class RootLuPidcontroller(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.PIDController'
        self.PidX = RootLuPidcontrollerPidx(self._context)
        self.PidUser1 = RootLuPidcontrollerPiduser1(self._context)
        self.PidW = RootLuPidcontrollerPidw(self._context)
        self.PidY = RootLuPidcontrollerPidy(self._context)
        self.PidUser2 = RootLuPidcontrollerPiduser2(self._context)


class RootLuCompdcInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance.Busy'


class RootLuCompdcInstanceAttributeCompdcgainx(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance.Attribute.CompDCGainX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainX.SetVectorString', *args)


class RootLuCompdcInstanceAttributeCoefficientindex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance.Attribute.CoefficientIndex'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CoefficientIndex.SetVectorString', *args)


class RootLuCompdcInstanceAttributeCompdcgainy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance.Attribute.CompDCGainY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainY.SetVectorString', *args)


class RootLuCompdcInstanceAttributeCompdcgainz(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance.Attribute.CompDCGainZ'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Attribute.CompDCGainZ.SetVectorString', *args)


class RootLuCompdcInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance.Attribute'
        self.CompDCGainZ = RootLuCompdcInstanceAttributeCompdcgainz(self._context)
        self.CompDCGainY = RootLuCompdcInstanceAttributeCompdcgainy(self._context)
        self.CoefficientIndex = RootLuCompdcInstanceAttributeCoefficientindex(self._context)
        self.CompDCGainX = RootLuCompdcInstanceAttributeCompdcgainx(self._context)


class RootLuCompdcInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance.Trigger'

    def ReadCurrentConfiguration(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Trigger.ReadCurrentConfiguration', *args)

    def ApplyNewNonlinearConfiguration(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Trigger.ApplyNewNonlinearConfiguration', *args)

    def ApplyNewConfiguration(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Trigger.ApplyNewConfiguration', *args)

    def StartCompDCCalibration(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Trigger.StartCompDCCalibration', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.CompDC.Instance.Trigger.UserAbort', *args)


class RootLuCompdcInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC.Instance'
        self.Trigger = RootLuCompdcInstanceTrigger(self._context)
        self.Attribute = RootLuCompdcInstanceAttribute(self._context)
        self.Busy = RootLuCompdcInstanceBusy(self._context)


class RootLuCompdc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.CompDC'
        self.Instance = RootLuCompdcInstance(self._context)


class RootLuFrequencysweepgenInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Busy'


class RootLuFrequencysweepgenInstanceAttributeSteptime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.StepTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StepTime.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeSweepamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SweepAmplitude.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeSensoramplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SensorAmplitude.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeSettletime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.SettleTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.SettleTime.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeLusiganalyzerinstno(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.LUSigAnalyzerInstNo.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeStartfrequency(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.StartFrequency.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeDatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.DataPoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.DataPoints.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeEndfrequency(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.EndFrequency.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttributeReferenceamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Attribute.ReferenceAmplitude.SetVectorString', *args)


class RootLuFrequencysweepgenInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Attribute'
        self.ReferenceAmplitude = RootLuFrequencysweepgenInstanceAttributeReferenceamplitude(self._context)
        self.EndFrequency = RootLuFrequencysweepgenInstanceAttributeEndfrequency(self._context)
        self.DataPoints = RootLuFrequencysweepgenInstanceAttributeDatapoints(self._context)
        self.StartFrequency = RootLuFrequencysweepgenInstanceAttributeStartfrequency(self._context)
        self.LUSigAnalyzerInstNo = RootLuFrequencysweepgenInstanceAttributeLusiganalyzerinstno(self._context)
        self.SettleTime = RootLuFrequencysweepgenInstanceAttributeSettletime(self._context)
        self.SensorAmplitude = RootLuFrequencysweepgenInstanceAttributeSensoramplitude(self._context)
        self.SweepAmplitude = RootLuFrequencysweepgenInstanceAttributeSweepamplitude(self._context)
        self.StepTime = RootLuFrequencysweepgenInstanceAttributeSteptime(self._context)


class RootLuFrequencysweepgenInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance.Trigger'

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Trigger.UserAbort', *args)

    def StartFrequencySweep(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Trigger.StartFrequencySweep', *args)

    def StartSetReferenceAmplitude(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Trigger.StartSetReferenceAmplitude', *args)

    def StartSetSensorAmplitude(self, *args) -> Any:
        return self._context.call('root.lu.FrequencySweepGen.Instance.Trigger.StartSetSensorAmplitude', *args)


class RootLuFrequencysweepgenInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen.Instance'
        self.Trigger = RootLuFrequencysweepgenInstanceTrigger(self._context)
        self.Attribute = RootLuFrequencysweepgenInstanceAttribute(self._context)
        self.Busy = RootLuFrequencysweepgenInstanceBusy(self._context)


class RootLuFrequencysweepgen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.FrequencySweepGen'
        self.Instance = RootLuFrequencysweepgenInstance(self._context)


class RootLuDataacquisitionInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Busy'

    def IsCapturing(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Busy.IsCapturing', *args)

    def IsSampling(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Busy.IsSampling', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch7input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh7Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehireschinputvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChInputVec.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributePhasesamplergroupid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerGroupID.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributePhasesamplerdataratevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerDataRateVec.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch1input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh1Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturefastchinputvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChInputVec.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresgroupid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResGroupID.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerautosetfiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerAutoSetFilterMode.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeActivesamplerset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveSamplerSet.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerdatarate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDataRate.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerfiltermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterMode.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerdatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerDatapoints.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerchannelmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerChannelMask.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch5input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh5Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturefastgroupid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastGroupID.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerfiltersize(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterSize.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch4input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh4Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch0input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh0Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch1input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh1Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplergroupid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerGroupID.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch3input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh3Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch2input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh2Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch5input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh5Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhireschinputvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResChInputVec.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributePhasemodeenabled(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseModeEnabled.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch7input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh7Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch6input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh6Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplertriggermode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerTriggerMode.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSelectactivecaptureset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SelectActiveCaptureSet.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributePhasecount(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.PhaseCount'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseCount.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch2input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh2Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeActivehiresdatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveHiResDatapoints.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeActivefastdatapoints(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.ActiveFastDatapoints.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch3input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh3Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehireschannelmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResChannelMask.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturefastchannelmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastChannelMask.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturefastch1input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh1Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerfiltercutoff(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterCutoff.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeNumberofsamplersets(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfSamplerSets.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch0input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh0Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturehiresch6input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureHiResCh6Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerfiltertype(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerFilterType.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturefastsamplingrate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastSamplingRate.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeCapturefastch0input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.CaptureFastCh0Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeNumberofcapturesets(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.NumberOfCaptureSets.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributeSamplerhiresch4input(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.SamplerHiResCh4Input.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttributePhasesamplerenddatapointvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Attribute.PhaseSamplerEndDatapointVec.SetVectorString', *args)


class RootLuDataacquisitionInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Attribute'
        self.PhaseSamplerEndDatapointVec = RootLuDataacquisitionInstanceAttributePhasesamplerenddatapointvec(self._context)
        self.SamplerHiResCh4Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch4input(self._context)
        self.NumberOfCaptureSets = RootLuDataacquisitionInstanceAttributeNumberofcapturesets(self._context)
        self.CaptureFastCh0Input = RootLuDataacquisitionInstanceAttributeCapturefastch0input(self._context)
        self.CaptureFastSamplingRate = RootLuDataacquisitionInstanceAttributeCapturefastsamplingrate(self._context)
        self.SamplerFilterType = RootLuDataacquisitionInstanceAttributeSamplerfiltertype(self._context)
        self.CaptureHiResCh6Input = RootLuDataacquisitionInstanceAttributeCapturehiresch6input(self._context)
        self.CaptureHiResCh0Input = RootLuDataacquisitionInstanceAttributeCapturehiresch0input(self._context)
        self.NumberOfSamplerSets = RootLuDataacquisitionInstanceAttributeNumberofsamplersets(self._context)
        self.SamplerFilterCutoff = RootLuDataacquisitionInstanceAttributeSamplerfiltercutoff(self._context)
        self.CaptureFastCh1Input = RootLuDataacquisitionInstanceAttributeCapturefastch1input(self._context)
        self.CaptureFastChannelMask = RootLuDataacquisitionInstanceAttributeCapturefastchannelmask(self._context)
        self.CaptureHiResChannelMask = RootLuDataacquisitionInstanceAttributeCapturehireschannelmask(self._context)
        self.CaptureHiResCh3Input = RootLuDataacquisitionInstanceAttributeCapturehiresch3input(self._context)
        self.ActiveFastDatapoints = RootLuDataacquisitionInstanceAttributeActivefastdatapoints(self._context)
        self.ActiveHiResDatapoints = RootLuDataacquisitionInstanceAttributeActivehiresdatapoints(self._context)
        self.CaptureHiResCh2Input = RootLuDataacquisitionInstanceAttributeCapturehiresch2input(self._context)
        self.PhaseCount = RootLuDataacquisitionInstanceAttributePhasecount(self._context)
        self.SelectActiveCaptureSet = RootLuDataacquisitionInstanceAttributeSelectactivecaptureset(self._context)
        self.SamplerTriggerMode = RootLuDataacquisitionInstanceAttributeSamplertriggermode(self._context)
        self.SamplerHiResCh6Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch6input(self._context)
        self.SamplerHiResCh7Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch7input(self._context)
        self.PhaseModeEnabled = RootLuDataacquisitionInstanceAttributePhasemodeenabled(self._context)
        self.SamplerHiResChInputVec = RootLuDataacquisitionInstanceAttributeSamplerhireschinputvec(self._context)
        self.SamplerHiResCh5Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch5input(self._context)
        self.SamplerHiResCh2Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch2input(self._context)
        self.SamplerHiResCh3Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch3input(self._context)
        self.SamplerGroupID = RootLuDataacquisitionInstanceAttributeSamplergroupid(self._context)
        self.SamplerHiResCh1Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch1input(self._context)
        self.SamplerHiResCh0Input = RootLuDataacquisitionInstanceAttributeSamplerhiresch0input(self._context)
        self.CaptureHiResCh4Input = RootLuDataacquisitionInstanceAttributeCapturehiresch4input(self._context)
        self.SamplerFilterSize = RootLuDataacquisitionInstanceAttributeSamplerfiltersize(self._context)
        self.CaptureFastGroupID = RootLuDataacquisitionInstanceAttributeCapturefastgroupid(self._context)
        self.CaptureHiResCh5Input = RootLuDataacquisitionInstanceAttributeCapturehiresch5input(self._context)
        self.SamplerChannelMask = RootLuDataacquisitionInstanceAttributeSamplerchannelmask(self._context)
        self.SamplerDatapoints = RootLuDataacquisitionInstanceAttributeSamplerdatapoints(self._context)
        self.SamplerFilterMode = RootLuDataacquisitionInstanceAttributeSamplerfiltermode(self._context)
        self.SamplerDataRate = RootLuDataacquisitionInstanceAttributeSamplerdatarate(self._context)
        self.ActiveSamplerSet = RootLuDataacquisitionInstanceAttributeActivesamplerset(self._context)
        self.SamplerAutoSetFilterMode = RootLuDataacquisitionInstanceAttributeSamplerautosetfiltermode(self._context)
        self.CaptureHiResGroupID = RootLuDataacquisitionInstanceAttributeCapturehiresgroupid(self._context)
        self.CaptureFastChInputVec = RootLuDataacquisitionInstanceAttributeCapturefastchinputvec(self._context)
        self.CaptureHiResCh1Input = RootLuDataacquisitionInstanceAttributeCapturehiresch1input(self._context)
        self.PhaseSamplerDataRateVec = RootLuDataacquisitionInstanceAttributePhasesamplerdataratevec(self._context)
        self.PhaseSamplerGroupID = RootLuDataacquisitionInstanceAttributePhasesamplergroupid(self._context)
        self.CaptureHiResChInputVec = RootLuDataacquisitionInstanceAttributeCapturehireschinputvec(self._context)
        self.CaptureHiResCh7Input = RootLuDataacquisitionInstanceAttributeCapturehiresch7input(self._context)


class RootLuDataacquisitionInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance.Trigger'

    def BackgroundSamplerStart(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.BackgroundSamplerStart', *args)

    def CapturePrepare(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.CapturePrepare', *args)

    def SamplerStartDataSimulation(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.SamplerStartDataSimulation', *args)

    def SamplerTrimDataStorage(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.SamplerTrimDataStorage', *args)

    def SamplerStart(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.SamplerStart', *args)

    def SamplerPrepare(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.SamplerPrepare', *args)

    def BackgroundCaptureStart(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.BackgroundCaptureStart', *args)

    def SamplerInitPhaseMode(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.SamplerInitPhaseMode', *args)

    def AbortAll(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.AbortAll', *args)

    def CaptureTrimDataStorage(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.CaptureTrimDataStorage', *args)

    def CaptureStartDataSimulation(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.CaptureStartDataSimulation', *args)

    def CaptureStart(self, *args) -> Any:
        return self._context.call('root.lu.DataAcquisition.Instance.Trigger.CaptureStart', *args)


class RootLuDataacquisitionInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition.Instance'
        self.Trigger = RootLuDataacquisitionInstanceTrigger(self._context)
        self.Attribute = RootLuDataacquisitionInstanceAttribute(self._context)
        self.Busy = RootLuDataacquisitionInstanceBusy(self._context)


class RootLuDataacquisition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.DataAcquisition'
        self.Instance = RootLuDataacquisitionInstance(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 RootLuScanheadInstanceAttributePtelaserpowermonitor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserPowerMonitor.SetVectorString', *args)


class RootLuScanheadInstanceAttributeReadoutlasersetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserSetpoint.SetVectorString', *args)


class RootLuScanheadInstanceAttributeTiltanglex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.TiltAngleX'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleX.SetVectorString', *args)


class RootLuScanheadInstanceAttributeReadoutlaserpowermonitor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.ReadoutLaserPowerMonitor.SetVectorString', *args)


class RootLuScanheadInstanceAttributeTiltangley(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.TiltAngleY'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltAngleY.SetVectorString', *args)


class RootLuScanheadInstanceAttributeTiltmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.TiltMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.TiltMode.SetVectorString', *args)


class RootLuScanheadInstanceAttributeHasxysensor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.HasXYSensor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasXYSensor.SetVectorString', *args)


class RootLuScanheadInstanceAttributeFastin2channel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.FastIn2Channel'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.FastIn2Channel.SetVectorString', *args)


class RootLuScanheadInstanceAttributeType(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.Type'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.Type.SetVectorString', *args)


class RootLuScanheadInstanceAttributeHaszsensor(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.HasZSensor'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.HasZSensor.SetVectorString', *args)


class RootLuScanheadInstanceAttributePtelasersetpoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Attribute.PTELaserSetpoint.SetVectorString', *args)


class RootLuScanheadInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Attribute'
        self.PTELaserSetpoint = RootLuScanheadInstanceAttributePtelasersetpoint(self._context)
        self.HasZSensor = RootLuScanheadInstanceAttributeHaszsensor(self._context)
        self.Type = RootLuScanheadInstanceAttributeType(self._context)
        self.FastIn2Channel = RootLuScanheadInstanceAttributeFastin2channel(self._context)
        self.HasXYSensor = RootLuScanheadInstanceAttributeHasxysensor(self._context)
        self.TiltMode = RootLuScanheadInstanceAttributeTiltmode(self._context)
        self.TiltAngleY = RootLuScanheadInstanceAttributeTiltangley(self._context)
        self.ReadoutLaserPowerMonitor = RootLuScanheadInstanceAttributeReadoutlaserpowermonitor(self._context)
        self.TiltAngleX = RootLuScanheadInstanceAttributeTiltanglex(self._context)
        self.ReadoutLaserSetpoint = RootLuScanheadInstanceAttributeReadoutlasersetpoint(self._context)
        self.PTELaserPowerMonitor = RootLuScanheadInstanceAttributePtelaserpowermonitor(self._context)


class RootLuScanheadInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance.Trigger'

    def DisableElectroThermalExcitation(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.DisableElectroThermalExcitation', *args)

    def DisablePTELaser(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.DisablePTELaser', *args)

    def EnableElectroThermalExcitation(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.EnableElectroThermalExcitation', *args)

    def ApplyTiltMode(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.ApplyTiltMode', *args)

    def EnableReadoutLaser(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.EnableReadoutLaser', *args)

    def DisableReadoutLaser(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.DisableReadoutLaser', *args)

    def DisablePiezoElectricExcitation(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.DisablePiezoElectricExcitation', *args)

    def EnablePTELaser(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.EnablePTELaser', *args)

    def EnablePiezoElectricExcitation(self, *args) -> Any:
        return self._context.call('root.lu.Scanhead.Instance.Trigger.EnablePiezoElectricExcitation', *args)


class RootLuScanheadInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Scanhead.Instance'
        self.Trigger = RootLuScanheadInstanceTrigger(self._context)
        self.Attribute = RootLuScanheadInstanceAttribute(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 RootLuOscilloscopeInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Oscilloscope.Instance.Busy'

    def IsBusy(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Busy.IsBusy', *args)


class RootLuOscilloscopeInstanceAttributeFastinputvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Oscilloscope.Instance.Attribute.FastInputVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.FastInputVec.SetVectorString', *args)


class RootLuOscilloscopeInstanceAttributeCaptureduration(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Oscilloscope.Instance.Attribute.CaptureDuration'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CaptureDuration.SetVectorString', *args)


class RootLuOscilloscopeInstanceAttributeCaptureperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Oscilloscope.Instance.Attribute.CapturePeriod'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.CapturePeriod.SetVectorString', *args)


class RootLuOscilloscopeInstanceAttributeHiresinputvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Oscilloscope.Instance.Attribute.HiResInputVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Attribute.HiResInputVec.SetVectorString', *args)


class RootLuOscilloscopeInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Oscilloscope.Instance.Attribute'
        self.HiResInputVec = RootLuOscilloscopeInstanceAttributeHiresinputvec(self._context)
        self.CapturePeriod = RootLuOscilloscopeInstanceAttributeCaptureperiod(self._context)
        self.CaptureDuration = RootLuOscilloscopeInstanceAttributeCaptureduration(self._context)
        self.FastInputVec = RootLuOscilloscopeInstanceAttributeFastinputvec(self._context)


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, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Trigger.Start', *args)

    def ToggleDebugLogging(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Trigger.ToggleDebugLogging', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.Oscilloscope.Instance.Trigger.Stop', *args)


class RootLuOscilloscopeInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Oscilloscope.Instance'
        self.Trigger = RootLuOscilloscopeInstanceTrigger(self._context)
        self.Attribute = RootLuOscilloscopeInstanceAttribute(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 RootLuMacrocmdInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Busy'


class RootLuMacrocmdInstanceAttributeI2cdata(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.I2CData'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CData.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeI2caddress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.I2CAddress'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CAddress.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeMomovestopmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopMode.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributePausetime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.PauseTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.PauseTime.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeI2cbus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.I2CBus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CBus.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeTargetoutputchannel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetOutputChannel.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeEnabledaqsyncend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQSyncEnd.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeSystemaborteventmask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.SystemAbortEventMask.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeActivesamplerset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ActiveSamplerSet.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeTargetzctrloutputmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.TargetZCtrlOutputMode.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeUsereventid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.UserEventID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.UserEventID.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeAbsoluteposmo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsolutePosMO.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeXymovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.XYMoveSpeed.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeMomovestopfeedbackmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopFeedbackMode.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeModulationoutput(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.ModulationOutput'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.ModulationOutput.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeRelativeposmo(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.RelativePosMO'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.RelativePosMO.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeI2cregister(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.I2CRegister'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.I2CRegister.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeAbsolutexpos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteXPos.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeAbsoluteypos(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.AbsoluteYPos.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeEnabledaq(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.EnableDAQ'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.EnableDAQ.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeMomovespeed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveSpeed.SetVectorString', *args)


class RootLuMacrocmdInstanceAttributeMomovestopvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Attribute.MOMoveStopValue.SetVectorString', *args)


class RootLuMacrocmdInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Attribute'
        self.MOMoveStopValue = RootLuMacrocmdInstanceAttributeMomovestopvalue(self._context)
        self.MOMoveSpeed = RootLuMacrocmdInstanceAttributeMomovespeed(self._context)
        self.EnableDAQ = RootLuMacrocmdInstanceAttributeEnabledaq(self._context)
        self.AbsoluteYPos = RootLuMacrocmdInstanceAttributeAbsoluteypos(self._context)
        self.AbsoluteXPos = RootLuMacrocmdInstanceAttributeAbsolutexpos(self._context)
        self.I2CRegister = RootLuMacrocmdInstanceAttributeI2cregister(self._context)
        self.RelativePosMO = RootLuMacrocmdInstanceAttributeRelativeposmo(self._context)
        self.ModulationOutput = RootLuMacrocmdInstanceAttributeModulationoutput(self._context)
        self.MOMoveStopFeedbackMode = RootLuMacrocmdInstanceAttributeMomovestopfeedbackmode(self._context)
        self.XYMoveSpeed = RootLuMacrocmdInstanceAttributeXymovespeed(self._context)
        self.AbsolutePosMO = RootLuMacrocmdInstanceAttributeAbsoluteposmo(self._context)
        self.UserEventID = RootLuMacrocmdInstanceAttributeUsereventid(self._context)
        self.TargetZCtrlOutputMode = RootLuMacrocmdInstanceAttributeTargetzctrloutputmode(self._context)
        self.ActiveSamplerSet = RootLuMacrocmdInstanceAttributeActivesamplerset(self._context)
        self.SystemAbortEventMask = RootLuMacrocmdInstanceAttributeSystemaborteventmask(self._context)
        self.EnableDAQSyncEnd = RootLuMacrocmdInstanceAttributeEnabledaqsyncend(self._context)
        self.TargetOutputChannel = RootLuMacrocmdInstanceAttributeTargetoutputchannel(self._context)
        self.I2CBus = RootLuMacrocmdInstanceAttributeI2cbus(self._context)
        self.PauseTime = RootLuMacrocmdInstanceAttributePausetime(self._context)
        self.MOMoveStopMode = RootLuMacrocmdInstanceAttributeMomovestopmode(self._context)
        self.I2CAddress = RootLuMacrocmdInstanceAttributeI2caddress(self._context)
        self.I2CData = RootLuMacrocmdInstanceAttributeI2cdata(self._context)


class RootLuMacrocmdInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance.Trigger'

    def MoveToRelMOPos(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.MoveToRelMOPos', *args)

    def MoveToAbsMOPos(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.MoveToAbsMOPos', *args)

    def MoveToStopValueMO(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.MoveToStopValueMO', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.UserAbort', *args)

    def MoveToAbsXYPos(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.MoveToAbsXYPos', *args)

    def ActivateZFeedback(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.ActivateZFeedback', *args)

    def MakePause(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.MakePause', *args)

    def WriteI2CData(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.WriteI2CData', *args)

    def AutoRecalibrateProbe(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.AutoRecalibrateProbe', *args)

    def UserEvent(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.UserEvent', *args)

    def StopZFeedback(self, *args) -> Any:
        return self._context.call('root.lu.MacroCmd.Instance.Trigger.StopZFeedback', *args)


class RootLuMacrocmdInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd.Instance'
        self.Trigger = RootLuMacrocmdInstanceTrigger(self._context)
        self.Attribute = RootLuMacrocmdInstanceAttribute(self._context)
        self.Busy = RootLuMacrocmdInstanceBusy(self._context)


class RootLuMacrocmd(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MacroCmd'
        self.Instance = RootLuMacrocmdInstance(self._context)


class RootLuSensorcontrolInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Busy'


class RootLuSensorcontrolInstanceAttributeEnable10hzupdatelaserspotondetectorstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.Enable10HzUpdateLaserSpotOnDetectorStatus.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttributeOffsetcalibigainmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGainMode.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttributeOffsetcalibmode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.OffsetCalibMode'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibMode.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttributeDetectorautoadjustmentstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAutoAdjustmentStatus.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttributeDetectoradjustmenttolerance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DetectorAdjustmentTolerance.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttributeOffsetcalibigain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.OffsetCalibIGain.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttributeSensoramplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.SensorAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.SensorAmplitude.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttributeDeflectionoffsetcalibrationstatus(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Attribute.DeflectionOffsetCalibrationStatus.SetVectorString', *args)


class RootLuSensorcontrolInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Attribute'
        self.DeflectionOffsetCalibrationStatus = RootLuSensorcontrolInstanceAttributeDeflectionoffsetcalibrationstatus(self._context)
        self.SensorAmplitude = RootLuSensorcontrolInstanceAttributeSensoramplitude(self._context)
        self.OffsetCalibIGain = RootLuSensorcontrolInstanceAttributeOffsetcalibigain(self._context)
        self.DetectorAdjustmentTolerance = RootLuSensorcontrolInstanceAttributeDetectoradjustmenttolerance(self._context)
        self.DetectorAutoAdjustmentStatus = RootLuSensorcontrolInstanceAttributeDetectorautoadjustmentstatus(self._context)
        self.OffsetCalibMode = RootLuSensorcontrolInstanceAttributeOffsetcalibmode(self._context)
        self.OffsetCalibIGainMode = RootLuSensorcontrolInstanceAttributeOffsetcalibigainmode(self._context)
        self.Enable10HzUpdateLaserSpotOnDetectorStatus = RootLuSensorcontrolInstanceAttributeEnable10hzupdatelaserspotondetectorstatus(self._context)


class RootLuSensorcontrolInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance.Trigger'

    def StartSensorCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.StartSensorCalibration', *args)

    def StartSetDynamicAmplitude(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.StartSetDynamicAmplitude', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.UserAbort', *args)

    def DeflectionOffsetCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.DeflectionOffsetCalibration', *args)

    def UpdateLaserSpotOnDetectorStatus(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.UpdateLaserSpotOnDetectorStatus', *args)

    def StartDetectorAutoAdjustment(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.StartDetectorAutoAdjustment', *args)

    def DeflectionOffsetCalibrationWithRetract(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.DeflectionOffsetCalibrationWithRetract', *args)

    def StartUpdateLaserSpotOnDetectorStatus(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.StartUpdateLaserSpotOnDetectorStatus', *args)

    def StartDeflectionOffsetCalibration(self, *args) -> Any:
        return self._context.call('root.lu.SensorControl.Instance.Trigger.StartDeflectionOffsetCalibration', *args)


class RootLuSensorcontrolInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl.Instance'
        self.Trigger = RootLuSensorcontrolInstanceTrigger(self._context)
        self.Attribute = RootLuSensorcontrolInstanceAttribute(self._context)
        self.Busy = RootLuSensorcontrolInstanceBusy(self._context)


class RootLuSensorcontrol(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.SensorControl'
        self.Instance = RootLuSensorcontrolInstance(self._context)


class RootLuThermaltuningInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ThermalTuning.Instance.Busy'


class RootLuThermaltuningInstanceAttributeBuffergroupid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ThermalTuning.Instance.Attribute.BufferGroupID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Attribute.BufferGroupID.SetVectorString', *args)


class RootLuThermaltuningInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ThermalTuning.Instance.Attribute'
        self.BufferGroupID = RootLuThermaltuningInstanceAttributeBuffergroupid(self._context)


class RootLuThermaltuningInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ThermalTuning.Instance.Trigger'

    def StartBlock(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Trigger.StartBlock', *args)

    def UserAbort(self, *args) -> Any:
        return self._context.call('root.lu.ThermalTuning.Instance.Trigger.UserAbort', *args)


class RootLuThermaltuningInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ThermalTuning.Instance'
        self.Trigger = RootLuThermaltuningInstanceTrigger(self._context)
        self.Attribute = RootLuThermaltuningInstanceAttribute(self._context)
        self.Busy = RootLuThermaltuningInstanceBusy(self._context)


class RootLuThermaltuning(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ThermalTuning'
        self.Instance = RootLuThermaltuningInstance(self._context)


class RootLuMainboardrelaysInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MainboardRelays.Instance.Busy'


class RootLuMainboardrelaysInstanceAttributeSetstatemask(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MainboardRelays.Instance.Attribute.SetStateMask'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MainboardRelays.Instance.Attribute.SetStateMask.SetVectorString', *args)


class RootLuMainboardrelaysInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MainboardRelays.Instance.Attribute'
        self.SetStateMask = RootLuMainboardrelaysInstanceAttributeSetstatemask(self._context)


class RootLuMainboardrelaysInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MainboardRelays.Instance.Trigger'


class RootLuMainboardrelaysInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MainboardRelays.Instance'
        self.Trigger = RootLuMainboardrelaysInstanceTrigger(self._context)
        self.Attribute = RootLuMainboardrelaysInstanceAttribute(self._context)
        self.Busy = RootLuMainboardrelaysInstanceBusy(self._context)


class RootLuMainboardrelays(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MainboardRelays'
        self.Instance = RootLuMainboardrelaysInstance(self._context)


class RootLuMemorysignalgenInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Busy'

    def IsBusy(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Busy.IsBusy', *args)


class RootLuMemorysignalgenInstanceAttributeFirstdatapointvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointValue.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeCurrentdatapoint(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.CurrentDatapoint.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeLastdatapointvaluebinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueBinaryVec.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeEndreached(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.EndReached'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.EndReached.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeDatagroupid(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.DataGroupID'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.DataGroupID.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeLastdatapointvaluevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LastDatapointValueVec.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeJoin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.Join'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.Join.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeFirstdatapointbinaryvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.FirstDatapointBinaryValue.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeLinearinterpolation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.LinearInterpolation.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeUnderrun(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.UnderRun'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.UnderRun.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeOffsetvaluebinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueBinaryVec.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeOutputbinaryvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputBinaryVec.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeSweeptime(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.SweepTime'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.SweepTime.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeOutputvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.OutputVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OutputVec.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttributeOffsetvaluevec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Attribute.OffsetValueVec.SetVectorString', *args)


class RootLuMemorysignalgenInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Attribute'
        self.OffsetValueVec = RootLuMemorysignalgenInstanceAttributeOffsetvaluevec(self._context)
        self.OutputVec = RootLuMemorysignalgenInstanceAttributeOutputvec(self._context)
        self.SweepTime = RootLuMemorysignalgenInstanceAttributeSweeptime(self._context)
        self.OutputBinaryVec = RootLuMemorysignalgenInstanceAttributeOutputbinaryvec(self._context)
        self.OffsetValueBinaryVec = RootLuMemorysignalgenInstanceAttributeOffsetvaluebinaryvec(self._context)
        self.UnderRun = RootLuMemorysignalgenInstanceAttributeUnderrun(self._context)
        self.LinearInterpolation = RootLuMemorysignalgenInstanceAttributeLinearinterpolation(self._context)
        self.FirstDatapointBinaryValue = RootLuMemorysignalgenInstanceAttributeFirstdatapointbinaryvalue(self._context)
        self.Join = RootLuMemorysignalgenInstanceAttributeJoin(self._context)
        self.LastDatapointValueVec = RootLuMemorysignalgenInstanceAttributeLastdatapointvaluevec(self._context)
        self.DataGroupID = RootLuMemorysignalgenInstanceAttributeDatagroupid(self._context)
        self.EndReached = RootLuMemorysignalgenInstanceAttributeEndreached(self._context)
        self.LastDatapointValueBinaryVec = RootLuMemorysignalgenInstanceAttributeLastdatapointvaluebinaryvec(self._context)
        self.CurrentDatapoint = RootLuMemorysignalgenInstanceAttributeCurrentdatapoint(self._context)
        self.FirstDatapointValue = RootLuMemorysignalgenInstanceAttributeFirstdatapointvalue(self._context)


class RootLuMemorysignalgenInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance.Trigger'

    def Start(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Trigger.Start', *args)

    def Abort(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Trigger.Abort', *args)

    def Stop(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Trigger.Stop', *args)

    def Prepare(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Trigger.Prepare', *args)

    def EnablePresetValue(self, *args) -> Any:
        return self._context.call('root.lu.MemorySignalGen.Instance.Trigger.EnablePresetValue', *args)


class RootLuMemorysignalgenInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen.Instance'
        self.Trigger = RootLuMemorysignalgenInstanceTrigger(self._context)
        self.Attribute = RootLuMemorysignalgenInstanceAttribute(self._context)
        self.Busy = RootLuMemorysignalgenInstanceBusy(self._context)


class RootLuMemorysignalgen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.MemorySignalGen'
        self.Instance = RootLuMemorysignalgenInstance(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'

    def IsAveraging(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Busy.IsAveraging', *args)


class RootLuOrtInstanceAttributeBaselineamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.BaselineAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineAmplitude.SetVectorString', *args)


class RootLuOrtInstanceAttributeSamplesperperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.SamplesPerPeriod'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.SamplesPerPeriod.SetVectorString', *args)


class RootLuOrtInstanceAttributeFeedbackamplitudeposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FeedbackAmplitudePosition.SetVectorString', *args)


class RootLuOrtInstanceAttributeCantileversamplesperperiod(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.CantileverSamplesPerPeriod.SetVectorString', *args)


class RootLuOrtInstanceAttributeAmplitudereduction(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.AmplitudeReduction'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AmplitudeReduction.SetVectorString', *args)


class RootLuOrtInstanceAttributeMinvalue(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.MinValue'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinValue.SetVectorString', *args)


class RootLuOrtInstanceAttributeBaselinewindowend(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.BaselineWindowEnd'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowEnd.SetVectorString', *args)


class RootLuOrtInstanceAttributeMinposition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.MinPosition'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.MinPosition.SetVectorString', *args)


class RootLuOrtInstanceAttributeFreewavedelay(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.FreeWaveDelay'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.FreeWaveDelay.SetVectorString', *args)


class RootLuOrtInstanceAttributeBaselinewindowbegin(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.BaselineWindowBegin'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineWindowBegin.SetVectorString', *args)


class RootLuOrtInstanceAttributeExcitationamplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.ExcitationAmplitude'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.ExcitationAmplitude.SetVectorString', *args)


class RootLuOrtInstanceAttributeInputselect(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.InputSelect'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.InputSelect.SetVectorString', *args)


class RootLuOrtInstanceAttributeBaselinefrequency(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.BaselineFrequency'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineFrequency.SetVectorString', *args)


class RootLuOrtInstanceAttributeAverageperiods(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.AveragePeriods'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.AveragePeriods.SetVectorString', *args)


class RootLuOrtInstanceAttributeBaselinecontrollerstate(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.BaselineControllerState'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.BaselineControllerState.SetVectorString', *args)


class RootLuOrtInstanceAttributeSubtracting(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute.Subtracting'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Attribute.Subtracting.SetVectorString', *args)


class RootLuOrtInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Attribute'
        self.Subtracting = RootLuOrtInstanceAttributeSubtracting(self._context)
        self.BaselineControllerState = RootLuOrtInstanceAttributeBaselinecontrollerstate(self._context)
        self.AveragePeriods = RootLuOrtInstanceAttributeAverageperiods(self._context)
        self.BaselineFrequency = RootLuOrtInstanceAttributeBaselinefrequency(self._context)
        self.InputSelect = RootLuOrtInstanceAttributeInputselect(self._context)
        self.ExcitationAmplitude = RootLuOrtInstanceAttributeExcitationamplitude(self._context)
        self.BaselineWindowBegin = RootLuOrtInstanceAttributeBaselinewindowbegin(self._context)
        self.FreeWaveDelay = RootLuOrtInstanceAttributeFreewavedelay(self._context)
        self.MinPosition = RootLuOrtInstanceAttributeMinposition(self._context)
        self.BaselineWindowEnd = RootLuOrtInstanceAttributeBaselinewindowend(self._context)
        self.MinValue = RootLuOrtInstanceAttributeMinvalue(self._context)
        self.AmplitudeReduction = RootLuOrtInstanceAttributeAmplitudereduction(self._context)
        self.CantileverSamplesPerPeriod = RootLuOrtInstanceAttributeCantileversamplesperperiod(self._context)
        self.FeedbackAmplitudePosition = RootLuOrtInstanceAttributeFeedbackamplitudeposition(self._context)
        self.SamplesPerPeriod = RootLuOrtInstanceAttributeSamplesperperiod(self._context)
        self.BaselineAmplitude = RootLuOrtInstanceAttributeBaselineamplitude(self._context)


class RootLuOrtInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance.Trigger'

    def UpdateFreeWave(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Trigger.UpdateFreeWave', *args)

    def AverageStop(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Trigger.AverageStop', *args)

    def ApplySamplesPerPeriod(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Trigger.ApplySamplesPerPeriod', *args)

    def ApplySamplesValues(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Trigger.ApplySamplesValues', *args)

    def ProcessAveragedSamples(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Trigger.ProcessAveragedSamples', *args)

    def AverageStart(self, *args) -> Any:
        return self._context.call('root.lu.Ort.Instance.Trigger.AverageStart', *args)


class RootLuOrtInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Ort.Instance'
        self.Trigger = RootLuOrtInstanceTrigger(self._context)
        self.Attribute = RootLuOrtInstanceAttribute(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 RootLuComparatorComparator2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2.Busy'


class RootLuComparatorComparator2AttributeFilterenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2.Attribute.FilterEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterEnable.SetVectorString', *args)


class RootLuComparatorComparator2AttributeSource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2.Attribute.Source'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Source.SetVectorString', *args)


class RootLuComparatorComparator2AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuComparatorComparator2AttributeLevel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2.Attribute.Level'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Level.SetVectorString', *args)


class RootLuComparatorComparator2AttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator2.Attribute.Polarity.SetVectorString', *args)


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.Level = RootLuComparatorComparator2AttributeLevel(self._context)
        self.FilterCoeffVec = RootLuComparatorComparator2AttributeFiltercoeffvec(self._context)
        self.Source = RootLuComparatorComparator2AttributeSource(self._context)
        self.FilterEnable = RootLuComparatorComparator2AttributeFilterenable(self._context)


class RootLuComparatorComparator2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2.Trigger'


class RootLuComparatorComparator2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator2'
        self.Trigger = RootLuComparatorComparator2Trigger(self._context)
        self.Attribute = RootLuComparatorComparator2Attribute(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 RootLuComparatorComparator1AttributeFilterenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator1.Attribute.FilterEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterEnable.SetVectorString', *args)


class RootLuComparatorComparator1AttributeSource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator1.Attribute.Source'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Source.SetVectorString', *args)


class RootLuComparatorComparator1AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuComparatorComparator1AttributeLevel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator1.Attribute.Level'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Level.SetVectorString', *args)


class RootLuComparatorComparator1AttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator1.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator1.Attribute.Polarity.SetVectorString', *args)


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.Level = RootLuComparatorComparator1AttributeLevel(self._context)
        self.FilterCoeffVec = RootLuComparatorComparator1AttributeFiltercoeffvec(self._context)
        self.Source = RootLuComparatorComparator1AttributeSource(self._context)
        self.FilterEnable = RootLuComparatorComparator1AttributeFilterenable(self._context)


class RootLuComparatorComparator1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator1.Trigger'


class RootLuComparatorComparator1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator1'
        self.Trigger = RootLuComparatorComparator1Trigger(self._context)
        self.Attribute = RootLuComparatorComparator1Attribute(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 RootLuComparatorComparator3AttributeFilterenable(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator3.Attribute.FilterEnable'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterEnable.SetVectorString', *args)


class RootLuComparatorComparator3AttributeSource(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator3.Attribute.Source'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Source.SetVectorString', *args)


class RootLuComparatorComparator3AttributeFiltercoeffvec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.FilterCoeffVec.SetVectorString', *args)


class RootLuComparatorComparator3AttributeLevel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator3.Attribute.Level'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Level.SetVectorString', *args)


class RootLuComparatorComparator3AttributePolarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator3.Attribute.Polarity'

    def SetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.SetVectorValueString', *args)

    def GetUnit(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetUnit', *args)

    def GetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetVectorString', *args)

    def GetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetValueString', *args)

    def GetMin(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetMin', *args)

    def SetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.SetVectorValue', *args)

    def SetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.SetVector', *args)

    def SetValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.SetValueString', *args)

    def SetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.SetValue', *args)

    def GetVectorValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetVectorValue', *args)

    def GetVector(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetVector', *args)

    def GetVectorValueString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetVectorValueString', *args)

    def GetMax(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetMax', *args)

    def GetValue(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.GetValue', *args)

    def SetVectorString(self, *args) -> Any:
        return self._context.call('root.lu.Comparator.Comparator3.Attribute.Polarity.SetVectorString', *args)


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.Level = RootLuComparatorComparator3AttributeLevel(self._context)
        self.FilterCoeffVec = RootLuComparatorComparator3AttributeFiltercoeffvec(self._context)
        self.Source = RootLuComparatorComparator3AttributeSource(self._context)
        self.FilterEnable = RootLuComparatorComparator3AttributeFilterenable(self._context)


class RootLuComparatorComparator3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator3.Trigger'


class RootLuComparatorComparator3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.Comparator.Comparator3'
        self.Trigger = RootLuComparatorComparator3Trigger(self._context)
        self.Attribute = RootLuComparatorComparator3Attribute(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 RootLu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu'
        self.Comparator = RootLuComparator(self._context)
        self.Ort = RootLuOrt(self._context)
        self.MemorySignalGen = RootLuMemorysignalgen(self._context)
        self.MainboardRelays = RootLuMainboardrelays(self._context)
        self.ThermalTuning = RootLuThermaltuning(self._context)
        self.SensorControl = RootLuSensorcontrol(self._context)
        self.MacroCmd = RootLuMacrocmd(self._context)
        self.Oscilloscope = RootLuOscilloscope(self._context)
        self.Scanhead = RootLuScanhead(self._context)
        self.DataAcquisition = RootLuDataacquisition(self._context)
        self.FrequencySweepGen = RootLuFrequencysweepgen(self._context)
        self.CompDC = RootLuCompdc(self._context)
        self.PIDController = RootLuPidcontroller(self._context)
        self.Approach = RootLuApproach(self._context)
        self.Test = RootLuTest(self._context)
        self.HVAmplifier = RootLuHvamplifier(self._context)
        self.Rescan = RootLuRescan(self._context)
        self.SignalAnalyzer = RootLuSignalanalyzer(self._context)
        self.Spec = RootLuSpec(self._context)
        self.AnalogHiResOut = RootLuAnaloghiresout(self._context)
        self.CantileverProperties = RootLuCantileverproperties(self._context)
        self.AnalogFastOut = RootLuAnalogfastout(self._context)
        self.SystemInfra = RootLuSysteminfra(self._context)
        self.DigiUserIO = RootLuDigiuserio(self._context)
        self.PositionControl = RootLuPositioncontrol(self._context)
        self.RampGenerator = RootLuRampgenerator(self._context)
        self.ZControllerEx = RootLuZcontrollerex(self._context)
        self.Scan = RootLuScan(self._context)
        self.AnalogFastIn = RootLuAnalogfastin(self._context)
        self.Timer = RootLuTimer(self._context)
        self.System = RootLuSystem(self._context)
        self.Sequencer = RootLuSequencer(self._context)
        self.AnalogHiResIn = RootLuAnaloghiresin(self._context)
        self.Litho = RootLuLitho(self._context)
        self.Isostage = RootLuIsostage(self._context)
        self.AutoAlignment = RootLuAutoalignment(self._context)
        self.EventManager = RootLuEventmanager(self._context)
        self.DirectMotorControl = RootLuDirectmotorcontrol(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 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 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 RootWorkflowDynamicProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.property'
        self.reference_phase = RootWorkflowDynamicPropertyReference_phase(self._context)
        self.excitation_amplitude = RootWorkflowDynamicPropertyExcitation_amplitude(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 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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation_done.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.update_free_vibration_amplitude.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.updating_free_amplitude_done.connect', *args)


class RootWorkflowDynamicSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.signal'
        self.updating_free_amplitude_done = RootWorkflowDynamicSignalUpdating_free_amplitude_done(self._context)
        self.changing_excitation = RootWorkflowDynamicSignalChanging_excitation(self._context)
        self.update_free_vibration_amplitude = RootWorkflowDynamicSignalUpdate_free_vibration_amplitude(self._context)
        self.changing_excitation_done = RootWorkflowDynamicSignalChanging_excitation_done(self._context)
        self.procedure_info = RootWorkflowDynamicSignalProcedure_info(self._context)


class RootWorkflowDynamic(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic'
        self.signal = RootWorkflowDynamicSignal(self._context)
        self.property = RootWorkflowDynamicProperty(self._context)

    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_excitation(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.update_excitation', *args)

    def update_free_vibration_amplitude(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.update_free_vibration_amplitude', *args)


class RootWorkflowParameters(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.parameters'


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 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_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 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 RootWorkflowSpectroscopyPropertySpecmap_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Point = 'Point'
        Map = 'Map'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowSpectroscopyPropertySpecmap_mode.EnumType(self._context.get('root.workflow.spectroscopy.property.specmap_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.spectroscopy.property.specmap_mode.value', new_val.value)

    @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 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 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_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 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 RootWorkflowSpectroscopyProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property'
        self.map_rotation = RootWorkflowSpectroscopyPropertyMap_rotation(self._context)
        self.map_start_y = RootWorkflowSpectroscopyPropertyMap_start_y(self._context)
        self.map_points_y = RootWorkflowSpectroscopyPropertyMap_points_y(self._context)
        self.point_offset_y = RootWorkflowSpectroscopyPropertyPoint_offset_y(self._context)
        self.map_end_y = RootWorkflowSpectroscopyPropertyMap_end_y(self._context)
        self.specmap_mode = RootWorkflowSpectroscopyPropertySpecmap_mode(self._context)
        self.point_offset_x = RootWorkflowSpectroscopyPropertyPoint_offset_x(self._context)
        self.map_end_x = RootWorkflowSpectroscopyPropertyMap_end_x(self._context)
        self.map_start_x = RootWorkflowSpectroscopyPropertyMap_start_x(self._context)
        self.map_points_x = RootWorkflowSpectroscopyPropertyMap_points_x(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 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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.signal.procedure_info.connect', *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_f_d_curve_experiment(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.create_f_d_curve_experiment', *args)

    def add_new_segment(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.add_new_segment', *args)

    def create_stress_relaxation_experiment(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.create_stress_relaxation_experiment', *args)


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 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 RootWorkflowStoragePropertyNidx_auto_store_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Off = 'Off'
        New_File = 'New File'
        Current_File = 'Current File'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowStoragePropertyNidx_auto_store_mode.EnumType(self._context.get('root.workflow.storage.property.nidx_auto_store_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.storage.property.nidx_auto_store_mode.value', new_val.value)

    @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 RootWorkflowStoragePropertyNhf_auto_store_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Off = 'Off'
        New_File = 'New File'
        Current_File = 'Current File'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowStoragePropertyNhf_auto_store_mode.EnumType(self._context.get('root.workflow.storage.property.nhf_auto_store_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.storage.property.nhf_auto_store_mode.value', new_val.value)

    @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 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 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 RootWorkflowStoragePropertyGwy_auto_store_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Off = 'Off'
        Store_to_file = 'Store to file'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowStoragePropertyGwy_auto_store_mode.EnumType(self._context.get('root.workflow.storage.property.gwy_auto_store_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.storage.property.gwy_auto_store_mode.value', new_val.value)

    @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 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 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 RootWorkflowStorageProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property'
        self.name_pattern = RootWorkflowStoragePropertyName_pattern(self._context)
        self.auto_save_partial_measurements = RootWorkflowStoragePropertyAuto_save_partial_measurements(self._context)
        self.gwy_auto_store_mode = RootWorkflowStoragePropertyGwy_auto_store_mode(self._context)
        self.gwy_backend_enabled = RootWorkflowStoragePropertyGwy_backend_enabled(self._context)
        self.gallery_directory = RootWorkflowStoragePropertyGallery_directory(self._context)
        self.nhf_auto_store_mode = RootWorkflowStoragePropertyNhf_auto_store_mode(self._context)
        self.nidx_auto_store_mode = RootWorkflowStoragePropertyNidx_auto_store_mode(self._context)
        self.nhf_backend_enabled = RootWorkflowStoragePropertyNhf_backend_enabled(self._context)
        self.nidx_backend_enabled = RootWorkflowStoragePropertyNidx_backend_enabled(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.measurement_image_opened.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.current_measurement_image_changed.connect', *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 RootWorkflowStorage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage'
        self.signal = RootWorkflowStorageSignal(self._context)
        self.property = RootWorkflowStorageProperty(self._context)

    def create_measurement(self, *args) -> Any:
        return self._context.call('root.workflow.storage.create_measurement', *args)

    def open_file(self, *args) -> Any:
        return self._context.call('root.workflow.storage.open_file', *args)

    def close_file(self, *args) -> Any:
        return self._context.call('root.workflow.storage.close_file', *args)


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_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_tunePropertyMeasurement_environment(wrap.CmdTreeProp):

    class EnumType(Enum):
        Air = 'Air'
        Liquid = 'Liquid'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowThermal_tunePropertyMeasurement_environment.EnumType(self._context.get('root.workflow.thermal_tune.property.measurement_environment.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.thermal_tune.property.measurement_environment.value', new_val.value)

    @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_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_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_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_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_tuneProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property'
        self.resolution = RootWorkflowThermal_tunePropertyResolution(self._context)
        self.fit_frequency_upper_bound = RootWorkflowThermal_tunePropertyFit_frequency_upper_bound(self._context)
        self.fit_frequency_lower_bound = RootWorkflowThermal_tunePropertyFit_frequency_lower_bound(self._context)
        self.iterations = RootWorkflowThermal_tunePropertyIterations(self._context)
        self.measurement_environment = RootWorkflowThermal_tunePropertyMeasurement_environment(self._context)
        self.max_frequency = RootWorkflowThermal_tunePropertyMax_frequency(self._context)
        self.temperature = RootWorkflowThermal_tunePropertyTemperature(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.current_calibration_changed.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_fit.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.progress.connect', *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 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)

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


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_calibration_data.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_frequency_list.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.ended.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_average.connect', *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.new_average = RootWorkflowThermal_tuneSignalNew_average(self._context)
        self.ended = RootWorkflowThermal_tuneSignalEnded(self._context)
        self.new_frequency_list = RootWorkflowThermal_tuneSignalNew_frequency_list(self._context)
        self.new_calibration_data = RootWorkflowThermal_tuneSignalNew_calibration_data(self._context)
        self.started = RootWorkflowThermal_tuneSignalStarted(self._context)
        self.progress = RootWorkflowThermal_tuneSignalProgress(self._context)
        self.procedure_info = RootWorkflowThermal_tuneSignalProcedure_info(self._context)
        self.new_fit = RootWorkflowThermal_tuneSignalNew_fit(self._context)
        self.current_calibration_changed = RootWorkflowThermal_tuneSignalCurrent_calibration_changed(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 start(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.start', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.abort', *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 refit(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.refit', *args)

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

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


class RootWorkflowFrequency_sweepPropertyFrequency_selection_criteria(wrap.CmdTreeProp):

    class EnumType(Enum):
        Below_Peak = 'Below Peak'
        Above_Peak = 'Above Peak'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowFrequency_sweepPropertyFrequency_selection_criteria.EnumType(self._context.get('root.workflow.frequency_sweep.property.frequency_selection_criteria.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.frequency_sweep.property.frequency_selection_criteria.value', new_val.value)

    @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_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_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_sweepPropertyMeasurement_environment(wrap.CmdTreeProp):

    class EnumType(Enum):
        Air = 'Air'
        Liquid = 'Liquid'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowFrequency_sweepPropertyMeasurement_environment.EnumType(self._context.get('root.workflow.frequency_sweep.property.measurement_environment.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.frequency_sweep.property.measurement_environment.value', new_val.value)

    @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_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_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_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_sweepPropertyAmplitude_unit(wrap.CmdTreeProp):

    class EnumType(Enum):
        Meters_m_ = 'Meters [m]'
        Volts_V_ = 'Volts [V]'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowFrequency_sweepPropertyAmplitude_unit.EnumType(self._context.get('root.workflow.frequency_sweep.property.amplitude_unit.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.frequency_sweep.property.amplitude_unit.value', new_val.value)

    @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_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_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_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_sweepPropertyAnalyzer_demodulator_bandwidth(wrap.CmdTreeProp):

    class EnumType(Enum):
        num_90_Hz = '90 Hz'
        num_180_Hz = '180 Hz'
        num_360_Hz = '360 Hz'
        num_750_Hz = '750 Hz'
        num_1500_Hz = '1500 Hz'
        num_3_kHz = '3 kHz'
        num_6_kHz = '6 kHz'
        num_12_kHz = '12 kHz'
        num_23_kHz = '23 kHz'
        num_45_kHz = '45 kHz'
        num_100_kHz = '100 kHz'
        num_230_kHz = '230 kHz'
        num_500_kHz = '500 kHz'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowFrequency_sweepPropertyAnalyzer_demodulator_bandwidth.EnumType(self._context.get('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.value', new_val.value)

    @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_sweepProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property'
        self.analyzer_demodulator_bandwidth = RootWorkflowFrequency_sweepPropertyAnalyzer_demodulator_bandwidth(self._context)
        self.fit_frequency_lower_bound = RootWorkflowFrequency_sweepPropertyFit_frequency_lower_bound(self._context)
        self.sweep_free_vibration_amplitude = RootWorkflowFrequency_sweepPropertySweep_free_vibration_amplitude(self._context)
        self.fit_frequency_upper_bound = RootWorkflowFrequency_sweepPropertyFit_frequency_upper_bound(self._context)
        self.amplitude_unit = RootWorkflowFrequency_sweepPropertyAmplitude_unit(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.sweep_data_points = RootWorkflowFrequency_sweepPropertySweep_data_points(self._context)
        self.amplitude_reduction = RootWorkflowFrequency_sweepPropertyAmplitude_reduction(self._context)
        self.measurement_environment = RootWorkflowFrequency_sweepPropertyMeasurement_environment(self._context)
        self.sweep_frequency_lower_bound = RootWorkflowFrequency_sweepPropertySweep_frequency_lower_bound(self._context)
        self.new_excitation_frequency = RootWorkflowFrequency_sweepPropertyNew_excitation_frequency(self._context)
        self.new_spring_constant = RootWorkflowFrequency_sweepPropertyNew_spring_constant(self._context)
        self.frequency_selection_criteria = RootWorkflowFrequency_sweepPropertyFrequency_selection_criteria(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_sweep_data.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.data_invalidated.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.ended.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.started.connect', *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 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)

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


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_fit_data.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sho_fit_failed.connect', *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.sho_fit_failed = RootWorkflowFrequency_sweepSignalSho_fit_failed(self._context)
        self.new_fit_data = RootWorkflowFrequency_sweepSignalNew_fit_data(self._context)
        self.sweep_progress = RootWorkflowFrequency_sweepSignalSweep_progress(self._context)
        self.started = RootWorkflowFrequency_sweepSignalStarted(self._context)
        self.ended = RootWorkflowFrequency_sweepSignalEnded(self._context)
        self.data_invalidated = RootWorkflowFrequency_sweepSignalData_invalidated(self._context)
        self.new_sweep_data = RootWorkflowFrequency_sweepSignalNew_sweep_data(self._context)
        self.procedure_info = RootWorkflowFrequency_sweepSignalProcedure_info(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 abort(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.abort', *args)

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

    def process_sweep_data(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.process_sweep_data', *args)


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

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

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

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

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.z_controller.property.max_z_value.unit', str(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_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_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_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_controllerPropertyFeedback(wrap.CmdTreeProp):

    class EnumType(Enum):
        Deflection = 'Deflection'
        WaveMode_Amplitude_Reduction = 'WaveMode Amplitude Reduction'
        Dynamic_Mode_Amplitude_Reduction = 'Dynamic Mode Amplitude Reduction'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowZ_controllerPropertyFeedback.EnumType(self._context.get('root.workflow.z_controller.property.feedback.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.z_controller.property.feedback.value', new_val.value)

    @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_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_controllerPropertyIdle_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Enable_Z_Controller = 'Enable Z Controller'
        Retract_Tip = 'Retract Tip'
        Keep_Last_Z_Position = 'Keep Last Z Position'
        Absolute_Z_Position = 'Absolute Z Position'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowZ_controllerPropertyIdle_mode.EnumType(self._context.get('root.workflow.z_controller.property.idle_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.z_controller.property.idle_mode.value', new_val.value)

    @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_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_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_controllerProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property'
        self.d_gain = RootWorkflowZ_controllerPropertyD_gain(self._context)
        self.setpoint = RootWorkflowZ_controllerPropertySetpoint(self._context)
        self.idle_mode = RootWorkflowZ_controllerPropertyIdle_mode(self._context)
        self.p_gain = RootWorkflowZ_controllerPropertyP_gain(self._context)
        self.feedback = RootWorkflowZ_controllerPropertyFeedback(self._context)
        self.actual_feedback_value = RootWorkflowZ_controllerPropertyActual_feedback_value(self._context)
        self.absolute_idle_position = RootWorkflowZ_controllerPropertyAbsolute_idle_position(self._context)
        self.i_gain = RootWorkflowZ_controllerPropertyI_gain(self._context)
        self.actual_tip_position = RootWorkflowZ_controllerPropertyActual_tip_position(self._context)
        self.max_z_value = RootWorkflowZ_controllerPropertyMax_z_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 retract_tip(self, *args) -> Any:
        return self._context.call('root.workflow.z_controller.retract_tip', *args)

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

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

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

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


class RootWorkflowWorkspace(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workspace'

    def delete_all_items(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.delete_all_items', *args)

    def set_item_position(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_position', *args)

    def add_frame(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.add_frame', *args)

    def get_item_position_y(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.get_item_position_y', *args)

    def set_item_resolution(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_resolution', *args)

    def add_grid(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.add_grid', *args)

    def add_point(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.add_point', *args)

    def default_afm_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.default_afm_item_id', *args)

    def set_item_visible(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_visible', *args)

    def item_count(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_count', *args)

    def set_item_transparency(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_transparency', *args)

    def set_item_size(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_size', *args)

    def set_item_rotation(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_rotation', *args)

    def set_item_name(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_name', *args)

    def selected_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.selected_item_id', *args)

    def active_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.active_item_id', *args)

    def item_name_exists(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_name_exists', *args)

    def item_id_by_name(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_id_by_name', *args)

    def get_item_position_x(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.get_item_position_x', *args)

    def all_item_ids_in_layer(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.all_item_ids_in_layer', *args)

    def get_item_name(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.get_item_name', *args)

    def item_exists(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_exists', *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)


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_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 RootWorkflowApproachPropertyStep_by_step_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Position_Controlled = 'Position Controlled'
        Not_Controlled = 'Not Controlled'
        Tip_Position_Ignored = 'Tip Position Ignored'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowApproachPropertyStep_by_step_mode.EnumType(self._context.get('root.workflow.approach.property.step_by_step_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.approach.property.step_by_step_mode.value', new_val.value)

    @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_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 RootWorkflowApproachPropertyMotor_source(wrap.CmdTreeProp):

    class EnumType(Enum):
        Internal = 'Internal'
        External = 'External'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowApproachPropertyMotor_source.EnumType(self._context.get('root.workflow.approach.property.motor_source.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.approach.property.motor_source.value', new_val.value)

    @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 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 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 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_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 RootWorkflowApproachPropertyApproach_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Continuous = 'Continuous'
        Step_by_Step = 'Step by Step'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowApproachPropertyApproach_mode.EnumType(self._context.get('root.workflow.approach.property.approach_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.approach.property.approach_mode.value', new_val.value)

    @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_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 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 RootWorkflowApproachProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property'
        self.approach_speed = RootWorkflowApproachPropertyApproach_speed(self._context)
        self.approach_pos = RootWorkflowApproachPropertyApproach_pos(self._context)
        self.approach_mode = RootWorkflowApproachPropertyApproach_mode(self._context)
        self.step_by_step_slope = RootWorkflowApproachPropertyStep_by_step_slope(self._context)
        self.step_by_step_fine_step_size_percentage = RootWorkflowApproachPropertyStep_by_step_fine_step_size_percentage(self._context)
        self.withdraw_steps = RootWorkflowApproachPropertyWithdraw_steps(self._context)
        self.step_by_step_time = RootWorkflowApproachPropertyStep_by_step_time(self._context)
        self.motor_source = RootWorkflowApproachPropertyMotor_source(self._context)
        self.step_by_step_deflection_offset_voltage = RootWorkflowApproachPropertyStep_by_step_deflection_offset_voltage(self._context)
        self.step_by_step_mode = RootWorkflowApproachPropertyStep_by_step_mode(self._context)
        self.step_by_step_coarse_step_size_percentage = RootWorkflowApproachPropertyStep_by_step_coarse_step_size_percentage(self._context)
        self.step_by_step_approach_result = RootWorkflowApproachPropertyStep_by_step_approach_result(self._context)
        self.approach_steps = RootWorkflowApproachPropertyApproach_steps(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_or_withdraw_finished.connect', *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 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)

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


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.withdraw_started.connect', *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 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)

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


class RootWorkflowApproachSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.signal'
        self.procedure_info = RootWorkflowApproachSignalProcedure_info(self._context)
        self.withdraw_started = RootWorkflowApproachSignalWithdraw_started(self._context)
        self.approach_started = RootWorkflowApproachSignalApproach_started(self._context)
        self.approach_or_withdraw_finished = RootWorkflowApproachSignalApproach_or_withdraw_finished(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 abort(self, *args) -> Any:
        return self._context.call('root.workflow.approach.abort', *args)

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

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

    def start_approach(self, *args) -> Any:
        return self._context.call('root.workflow.approach.start_approach', *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 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_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_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_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_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_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_motorsProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property'
        self.relative_tip_position = RootWorkflowApproach_motorsPropertyRelative_tip_position(self._context)
        self.motor_speed = RootWorkflowApproach_motorsPropertyMotor_speed(self._context)
        self.motor_right_position = RootWorkflowApproach_motorsPropertyMotor_right_position(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.motor_speed_advance_retract = RootWorkflowApproach_motorsPropertyMotor_speed_advance_retract(self._context)
        self.motor_speed_approach_motors = RootWorkflowApproach_motorsPropertyMotor_speed_approach_motors(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_finished.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_started.connect', *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.motor_move_finished = RootWorkflowApproach_motorsSignalMotor_move_finished(self._context)
        self.procedure_info = RootWorkflowApproach_motorsSignalProcedure_info(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.signal = RootWorkflowApproach_motorsSignal(self._context)
        self.property = RootWorkflowApproach_motorsProperty(self._context)

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


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 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 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 add_all_accessible_items_to_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.add_all_accessible_items_to_queue', *args)

    def clear_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.clear_queue', *args)

    def is_running(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_running', *args)

    def process(self, *args) -> Any:
        return self._context.call('root.workflow.automation.process', *args)

    def is_item_queued(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_item_queued', *args)

    def update_queue_entry(self, *args) -> Any:
        return self._context.call('root.workflow.automation.update_queue_entry', *args)

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

    def is_paused(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_paused', *args)

    def is_idle(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_idle', *args)

    def add_to_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.add_to_queue', *args)

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

    def remove_from_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.remove_from_queue', *args)

    def resume(self, *args) -> Any:
        return self._context.call('root.workflow.automation.resume', *args)

    def reset_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.reset_queue', *args)

    def pause(self, *args) -> Any:
        return self._context.call('root.workflow.automation.pause', *args)

    def queue_info(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_info', *args)

    def queue_index_by_item_name(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_index_by_item_name', *args)

    def move_queue_entry(self, *args) -> Any:
        return self._context.call('root.workflow.automation.move_queue_entry', *args)

    def queue_size(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_size', *args)

    def queue_index_by_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_index_by_item_id', *args)

    def insert_in_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.insert_in_queue', *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 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 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)

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


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_finished.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_started.connect', *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.motor_move_finished = RootWorkflowLaser_alignSignalMotor_move_finished(self._context)
        self.procedure_info = RootWorkflowLaser_alignSignalProcedure_info(self._context)


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_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_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_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_alignPropertyDeflection_offset_calibration_status(wrap.CmdTreeProp):

    class EnumType(Enum):
        No_Error = 'No Error'
        Calibration_Error = 'Calibration Error'
        Sensor_Signal_Failed = 'Sensor Signal Failed'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowLaser_alignPropertyDeflection_offset_calibration_status.EnumType(self._context.get('root.workflow.laser_align.property.deflection_offset_calibration_status.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.laser_align.property.deflection_offset_calibration_status.value', new_val.value)

    @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_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_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_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_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_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_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_alignPropertySensor_status(wrap.CmdTreeProp):

    class EnumType(Enum):
        Undefined = 'Undefined'
        Low = 'Low'
        Ok = 'Ok'
        High = 'High'
        Fail = 'Fail'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowLaser_alignPropertySensor_status.EnumType(self._context.get('root.workflow.laser_align.property.sensor_status.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.laser_align.property.sensor_status.value', new_val.value)

    @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_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_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_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_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_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_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_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_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_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_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_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_alignProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property'
        self.deflection_lateral = RootWorkflowLaser_alignPropertyDeflection_lateral(self._context)
        self.motor_laser_focus_z_position = RootWorkflowLaser_alignPropertyMotor_laser_focus_z_position(self._context)
        self.motor_laser_readout_x_position = RootWorkflowLaser_alignPropertyMotor_laser_readout_x_position(self._context)
        self.motor_laser_photodetector_x_position = RootWorkflowLaser_alignPropertyMotor_laser_photodetector_x_position(self._context)
        self.deflection_normal = RootWorkflowLaser_alignPropertyDeflection_normal(self._context)
        self.motor_laser_readout_y_position = RootWorkflowLaser_alignPropertyMotor_laser_readout_y_position(self._context)
        self.motor_laser_clean_drive_x_position = RootWorkflowLaser_alignPropertyMotor_laser_clean_drive_x_position(self._context)
        self.laser_readout_enabled = RootWorkflowLaser_alignPropertyLaser_readout_enabled(self._context)
        self.update_detector_rate = RootWorkflowLaser_alignPropertyUpdate_detector_rate(self._context)
        self.laser_spot_intensity = RootWorkflowLaser_alignPropertyLaser_spot_intensity(self._context)
        self.scan_mode = RootWorkflowLaser_alignPropertyScan_mode(self._context)
        self.sensor_status = RootWorkflowLaser_alignPropertySensor_status(self._context)
        self.motor_step = RootWorkflowLaser_alignPropertyMotor_step(self._context)
        self.laser_clean_drive_enabled = RootWorkflowLaser_alignPropertyLaser_clean_drive_enabled(self._context)
        self.motor_speed_max_laser_motors = RootWorkflowLaser_alignPropertyMotor_speed_max_laser_motors(self._context)
        self.motor_speed_laser_motors = RootWorkflowLaser_alignPropertyMotor_speed_laser_motors(self._context)
        self.motor_laser_photodetector_y_position = RootWorkflowLaser_alignPropertyMotor_laser_photodetector_y_position(self._context)
        self.laser_readout_power = RootWorkflowLaser_alignPropertyLaser_readout_power(self._context)
        self.deflection_offset_calibration_status = RootWorkflowLaser_alignPropertyDeflection_offset_calibration_status(self._context)
        self.laser_clean_drive_amplitude = RootWorkflowLaser_alignPropertyLaser_clean_drive_amplitude(self._context)
        self.motor_laser_clean_drive_y_position = RootWorkflowLaser_alignPropertyMotor_laser_clean_drive_y_position(self._context)
        self.laser_clean_drive_power = RootWorkflowLaser_alignPropertyLaser_clean_drive_power(self._context)
        self.motor_beam_shifter_position = RootWorkflowLaser_alignPropertyMotor_beam_shifter_position(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 adjust_motor_speed(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.adjust_motor_speed', *args)

    def start_auto_align(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.start_auto_align', *args)

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

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

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

    def is_idle(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.is_idle', *args)

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

    def is_checking_thermal(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.is_checking_thermal', *args)


class RootWorkflowWorkflow_options(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_options'


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_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_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_index = RootWorkflowCantileverPropertySelected_cantilever_index(self._context)
        self.selected_cantilever_spring_constant = RootWorkflowCantileverPropertySelected_cantilever_spring_constant(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 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)

    def spring_constant(self, *args) -> Any:
        return self._context.call('root.workflow.cantilever.spring_constant', *args)


class RootWorkflowSystem_startup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.system_startup'


class RootWorkflowMode_loader(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.mode_loader'


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 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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.remaining_scan_time_changed.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_paused.connect', *args)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_finished.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_started.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_resumed.connect', *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_resumed = RootWorkflowImagingSignalScanning_resumed(self._context)
        self.scanning_started = RootWorkflowImagingSignalScanning_started(self._context)
        self.scanning_finished = RootWorkflowImagingSignalScanning_finished(self._context)
        self.scanning_paused = RootWorkflowImagingSignalScanning_paused(self._context)
        self.remaining_scan_time_changed = RootWorkflowImagingSignalRemaining_scan_time_changed(self._context)
        self.procedure_info = RootWorkflowImagingSignalProcedure_info(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_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))

    @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))


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 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 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 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 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 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 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 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 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 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 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 RootWorkflowImagingPropertySlow_axis_scan_direction(wrap.CmdTreeProp):

    class EnumType(Enum):
        Downward = 'Downward'
        Upward = 'Upward'
        Bounce = 'Bounce'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowImagingPropertySlow_axis_scan_direction.EnumType(self._context.get('root.workflow.imaging.property.slow_axis_scan_direction.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.imaging.property.slow_axis_scan_direction.value', new_val.value)

    @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 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 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 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 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 RootWorkflowImagingPropertyScan_mode(wrap.CmdTreeProp):

    class EnumType(Enum):
        Continuous = 'Continuous'
        Single_Frame = 'Single Frame'

    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) -> EnumType:
        return RootWorkflowImagingPropertyScan_mode.EnumType(self._context.get('root.workflow.imaging.property.scan_mode.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.imaging.property.scan_mode.value', new_val.value)

    @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 RootWorkflowImagingProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property'
        self.backward_points_per_line = RootWorkflowImagingPropertyBackward_points_per_line(self._context)
        self.scan_mode = RootWorkflowImagingPropertyScan_mode(self._context)
        self.move_speed_xy = RootWorkflowImagingPropertyMove_speed_xy(self._context)
        self.finish_current_frame_and_stop = RootWorkflowImagingPropertyFinish_current_frame_and_stop(self._context)
        self.points_per_line = RootWorkflowImagingPropertyPoints_per_line(self._context)
        self.lines_per_frame = RootWorkflowImagingPropertyLines_per_frame(self._context)
        self.slow_axis_scan_direction = RootWorkflowImagingPropertySlow_axis_scan_direction(self._context)
        self.scan_range_slow_axis = RootWorkflowImagingPropertyScan_range_slow_axis(self._context)
        self.time_per_line = RootWorkflowImagingPropertyTime_per_line(self._context)
        self.line_rate = RootWorkflowImagingPropertyLine_rate(self._context)
        self.image_offset_x = RootWorkflowImagingPropertyImage_offset_x(self._context)
        self.image_offset_y = RootWorkflowImagingPropertyImage_offset_y(self._context)
        self.slope_x = RootWorkflowImagingPropertySlope_x(self._context)
        self.tip_velocity = RootWorkflowImagingPropertyTip_velocity(self._context)
        self.slope_y = RootWorkflowImagingPropertySlope_y(self._context)
        self.scan_range_fast_axis = RootWorkflowImagingPropertyScan_range_fast_axis(self._context)
        self.rotation = RootWorkflowImagingPropertyRotation(self._context)
        self.overscan = RootWorkflowImagingPropertyOverscan(self._context)


class RootWorkflowImaging(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging'
        self.property = RootWorkflowImagingProperty(self._context)
        self.var = RootWorkflowImagingVar(self._context)
        self.signal = RootWorkflowImagingSignal(self._context)

    def is_scanning(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.is_scanning', *args)

    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)


class RootWorkflowSignal_selection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.signal_selection'


class RootWorkflowWorkflow_monitoring(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_monitoring'


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 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 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_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 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 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 RootWorkflowOrtPropertyInput_select(wrap.CmdTreeProp):

    class EnumType(Enum):
        Fast_In_Deflection = 'Fast In Deflection'
        Hi_Res_In_Deflection = 'Hi Res In Deflection'
        Fast_In_User = 'Fast In User'
        Hi_Res_In_User1 = 'Hi Res In User1'

    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('str')

    @property
    def value(self) -> EnumType:
        return RootWorkflowOrtPropertyInput_select.EnumType(self._context.get('root.workflow.ort.property.input_select.value'))

    @value.setter
    def value(self, new_val:EnumType):
        self._context.set('root.workflow.ort.property.input_select.value', new_val.value)

    @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 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 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 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 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 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 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 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 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 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 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 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 RootWorkflowOrtProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property'
        self.baseline_window_end = RootWorkflowOrtPropertyBaseline_window_end(self._context)
        self.baseline_frequency = RootWorkflowOrtPropertyBaseline_frequency(self._context)
        self.cantilever_samples_per_period = RootWorkflowOrtPropertyCantilever_samples_per_period(self._context)
        self.adhesion_position = RootWorkflowOrtPropertyAdhesion_position(self._context)
        self.baseline_controller_enabled = RootWorkflowOrtPropertyBaseline_controller_enabled(self._context)
        self.adhesion_value = RootWorkflowOrtPropertyAdhesion_value(self._context)
        self.baseline_window_begin = RootWorkflowOrtPropertyBaseline_window_begin(self._context)
        self.feedback_amplitude_position = RootWorkflowOrtPropertyFeedback_amplitude_position(self._context)
        self.wave_frequency = RootWorkflowOrtPropertyWave_frequency(self._context)
        self.samples_per_period = RootWorkflowOrtPropertySamples_per_period(self._context)
        self.wave_amplitude = RootWorkflowOrtPropertyWave_amplitude(self._context)
        self.excitation_amplitude = RootWorkflowOrtPropertyExcitation_amplitude(self._context)
        self.input_select = RootWorkflowOrtPropertyInput_select(self._context)
        self.free_wave_delay = RootWorkflowOrtPropertyFree_wave_delay(self._context)
        self.lift_height = RootWorkflowOrtPropertyLift_height(self._context)
        self.baseline_amplitude = RootWorkflowOrtPropertyBaseline_amplitude(self._context)
        self.average_periods = RootWorkflowOrtPropertyAverage_periods(self._context)
        self.baseline_value = RootWorkflowOrtPropertyBaseline_value(self._context)
        self.amplitude_reduction = RootWorkflowOrtPropertyAmplitude_reduction(self._context)


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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.procedure_info.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation_done.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave_done.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave.connect', *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 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)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.oscilloscope_data.connect', *args)


class RootWorkflowOrtSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal'
        self.oscilloscope_data = RootWorkflowOrtSignalOscilloscope_data(self._context)
        self.updating_free_wave = RootWorkflowOrtSignalUpdating_free_wave(self._context)
        self.changing_excitation = RootWorkflowOrtSignalChanging_excitation(self._context)
        self.updating_free_wave_done = RootWorkflowOrtSignalUpdating_free_wave_done(self._context)
        self.changing_excitation_done = RootWorkflowOrtSignalChanging_excitation_done(self._context)
        self.procedure_info = RootWorkflowOrtSignalProcedure_info(self._context)


class RootWorkflowOrt(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort'
        self.signal = RootWorkflowOrtSignal(self._context)
        self.property = RootWorkflowOrtProperty(self._context)

    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)

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


class RootWorkflow(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow'
        self.ort = RootWorkflowOrt(self._context)
        self.workflow_monitoring = RootWorkflowWorkflow_monitoring(self._context)
        self.signal_selection = RootWorkflowSignal_selection(self._context)
        self.imaging = RootWorkflowImaging(self._context)
        self.manager = RootWorkflowManager(self._context)
        self.mode_loader = RootWorkflowMode_loader(self._context)
        self.system_startup = RootWorkflowSystem_startup(self._context)
        self.cantilever = RootWorkflowCantilever(self._context)
        self.workflow_options = RootWorkflowWorkflow_options(self._context)
        self.laser_align = RootWorkflowLaser_align(self._context)
        self.camera_properties = RootWorkflowCamera_properties(self._context)
        self.automation = RootWorkflowAutomation(self._context)
        self.spm_resource_requester = RootWorkflowSpm_resource_requester(self._context)
        self.comp_dc = RootWorkflowComp_dc(self._context)
        self.approach_motors = RootWorkflowApproach_motors(self._context)
        self.xy_closed_loop = RootWorkflowXy_closed_loop(self._context)
        self.approach = RootWorkflowApproach(self._context)
        self.workspace = RootWorkflowWorkspace(self._context)
        self.z_controller = RootWorkflowZ_controller(self._context)
        self.frequency_sweep = RootWorkflowFrequency_sweep(self._context)
        self.thermal_tune = RootWorkflowThermal_tune(self._context)
        self.storage = RootWorkflowStorage(self._context)
        self.workflow_spectroscopy_setup = RootWorkflowWorkflow_spectroscopy_setup(self._context)
        self.spectroscopy = RootWorkflowSpectroscopy(self._context)
        self.parameters = RootWorkflowParameters(self._context)
        self.dynamic = RootWorkflowDynamic(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.test = RootTest(self._context)
        self.util = RootUtil(self._context)
        self.session = RootSession(self._context)
        self.seq = RootSeq(self._context)
        self.core = RootCore(self._context)

    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_debug(self, *args) -> Any:
        return self._context.call('root.log_debug', *args)

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

    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))


