def __init__(self, A = None, B = None):
     from marketsim.gen._out.strategy._noise import Noise_IEventSideIObservableIOrder as _strategy_Noise_IEventSideIObservableIOrder
     from marketsim import rtti
     self.A = A if A is not None else _strategy_Noise_IEventSideIObservableIOrder()
     self.B = B if B is not None else _strategy_Noise_IEventSideIObservableIOrder()
     rtti.check_fields(self)
     _Combine_Impl.__init__(self)

 def __init__(self, up = None, down = None):
     from marketsim.gen._out.orderbook._link import Link_IObservableFloat as _orderbook_Link_IObservableFloat
     from marketsim import rtti
     self.up = up if up is not None else _orderbook_Link_IObservableFloat()
     self.down = down if down is not None else _orderbook_Link_IObservableFloat()
     rtti.check_fields(self)
     _TwoWayLink_Impl.__init__(self)

 def __init__(self, maxloss = None, proto = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim.gen._out.order._curried._sidevolume_price_limit import sidevolume_price_Limit_ as _order__curried_sidevolume_price_Limit_
     from marketsim import rtti
     self.maxloss = maxloss if maxloss is not None else _constant_Float(0.1)
     self.proto = proto if proto is not None else _order__curried_sidevolume_price_Limit_()
     rtti.check_fields(self)

 def __init__(self, trader = None, alpha = None):
     from marketsim.gen._out.trader._singleproxy import SingleProxy_ as _trader_SingleProxy_
     from marketsim import rtti
     self.trader = trader if trader is not None else _trader_SingleProxy_()
     self.alpha = alpha if alpha is not None else 0.15
     rtti.check_fields(self)
     self.impl = self.getImpl()

 def __init__(self, side = None, volume = None):
     from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     self.side = side if side is not None else _side_Sell_()
     self.volume = volume if volume is not None else _constant_Float(1.0)
     rtti.check_fields(self)

 def __init__(self, proto = None, lotSize = None):
     from marketsim.gen._out.order._curried._sidevolume_price_limit import sidevolume_price_Limit_ as _order__curried_sidevolume_price_Limit_
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     self.proto = proto if proto is not None else _order__curried_sidevolume_price_Limit_()
     self.lotSize = lotSize if lotSize is not None else _constant_Float(10.0)
     rtti.check_fields(self)

 def __init__(self, floatingPrice = None, proto = None):
     from marketsim.gen._out._const import const_Float as _const_Float
     from marketsim.gen._out.order._curried._side_price_limit import side_price_Limit_Float as _order__curried_side_price_Limit_Float
     from marketsim import rtti
     self.floatingPrice = floatingPrice if floatingPrice is not None else _const_Float(10.0)
     self.proto = proto if proto is not None else _order__curried_side_price_Limit_Float()
     rtti.check_fields(self)

 def __init__(self, queue = None, alpha = None):
     from marketsim.gen._out.orderbook._asks import Asks_IOrderBook as _orderbook_Asks_IOrderBook
     from marketsim import rtti
     self.queue = queue if queue is not None else _orderbook_Asks_IOrderBook()
     self.alpha = alpha if alpha is not None else 0.15
     rtti.check_fields(self)
     self.impl = self.getImpl()

 def __init__(self, source = None, timeframe = None):
     from marketsim.gen._out._const import const_Float as _const_Float
     from marketsim import rtti
     self.source = source if source is not None else _const_Float(1.0)
     self.timeframe = timeframe if timeframe is not None else 100.0
     rtti.check_fields(self)
     self.impl = self.getImpl()

 def __init__(self, source = None, alpha = None):
     from marketsim.gen._out._const import const_Float as _const_Float
     from marketsim import rtti
     self.source = source if source is not None else _const_Float(1.0)
     self.alpha = alpha if alpha is not None else 0.015
     rtti.check_fields(self)
     EWMV_Impl.__init__(self)

 def __init__(self, book = None, alpha = None):
     from marketsim.gen._out.orderbook._oftrader import OfTrader_IAccount as _orderbook_OfTrader_IAccount
     from marketsim import rtti
     self.book = book if book is not None else _orderbook_OfTrader_IAccount()
     self.alpha = alpha if alpha is not None else 0.15
     rtti.check_fields(self)
     self.impl = self.getImpl()

 def __init__(self, f = None, base = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     self.f = f if f is not None else _constant_Float(1.0)
     self.base = base if base is not None else 1.002
     rtti.check_fields(self)
     self.impl = self.getImpl()

 def __init__(self):
     from marketsim.gen._out._observable import Observablebool
     from marketsim import rtti
     Observablebool.__init__(self)
     
     rtti.check_fields(self)
     _True_Impl.__init__(self)

 def __init__(self, expiry = None, proto = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim.gen._out.order._curried._sidevolume_limit import sidevolume_Limit_Float as _order__curried_sidevolume_Limit_Float
     from marketsim import rtti
     self.expiry = expiry if expiry is not None else _constant_Float(10.0)
     self.proto = proto if proto is not None else _order__curried_sidevolume_Limit_Float()
     rtti.check_fields(self)

 def __init__(self, inner = None, predicate = None):
     from marketsim.gen._out.strategy._noise import Noise_IEventSideIObservableIOrder as _strategy_Noise_IEventSideIObservableIOrder
     from marketsim.gen._out._true import true_ as _true_
     from marketsim import rtti
     self.inner = inner if inner is not None else _strategy_Noise_IEventSideIObservableIOrder()
     self.predicate = predicate if predicate is not None else _true_()
     rtti.check_fields(self)
     _Suspendable_Impl.__init__(self)

 def __init__(self, x = None):
     from marketsim.gen._out._iobservable import IObservableint
     from marketsim import rtti
     IObservableint.__init__(self)
     self.x = x if x is not None else 1
     
     rtti.check_fields(self)
     _Constant_Impl.__init__(self)

 def __init__(self, x = None):
     from marketsim.gen._out._observable import Observablefloat
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     Observablefloat.__init__(self)
     self.x = x if x is not None else _constant_Float(1.0)
     
     rtti.check_fields(self)

 def __init__(self, x = None, slow = None, fast = None):
     from marketsim.gen._out._const import const_Float as _const_Float
     from marketsim import rtti
     self.x = x if x is not None else _const_Float(1.0)
     self.slow = slow if slow is not None else 26.0
     self.fast = fast if fast is not None else 12.0
     rtti.check_fields(self)
     self.impl = self.getImpl()

 def __init__(self, name = None, tickSize = None, _digitsToShow = None, timeseries = None):
     from marketsim import rtti
     self.name = name if name is not None else "-orderbook-"
     self.tickSize = tickSize if tickSize is not None else 0.01
     self._digitsToShow = _digitsToShow if _digitsToShow is not None else 2
     self.timeseries = timeseries if timeseries is not None else []
     rtti.check_fields(self)
     _Local_Impl.__init__(self)

 def __init__(self, orderFactory = None, eventGen = None):
     from marketsim.gen._out.order._limit import Limit_SideFloatFloat as _order_Limit_SideFloatFloat
     from marketsim.gen._out.event._every import Every_Float as _event_Every_Float
     from marketsim import rtti
     self.orderFactory = orderFactory if orderFactory is not None else _order_Limit_SideFloatFloat()
     self.eventGen = eventGen if eventGen is not None else _event_Every_Float()
     rtti.check_fields(self)
     _Generic_Impl.__init__(self)