quantwave 0.1.14__py3-none-win_amd64.whl

quantwave/quantwave_python/quantwave_python.py

@@ -0,0 +1,4038 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .py file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Python
+# helpers directly inline like we're doing here.
+
+from __future__ import annotations
+import os
+import sys
+import ctypes
+from dataclasses import dataclass
+import enum
+import struct
+import contextlib
+import datetime
+import threading
+import itertools
+import traceback
+import typing
+import platform
+
+
+# Used for default argument values
+_DEFAULT = object() # type: typing.Any
+
+
+class _UniffiRustBuffer(ctypes.Structure):
+    _fields_ = [
+        ("capacity", ctypes.c_uint64),
+        ("len", ctypes.c_uint64),
+        ("data", ctypes.POINTER(ctypes.c_char)),
+    ]
+
+    @staticmethod
+    def default():
+        return _UniffiRustBuffer(0, 0, None)
+
+    @staticmethod
+    def alloc(size):
+        return _uniffi_rust_call(_UniffiLib.ffi_quantwave_python_rustbuffer_alloc, size)
+
+    @staticmethod
+    def reserve(rbuf, additional):
+        return _uniffi_rust_call(_UniffiLib.ffi_quantwave_python_rustbuffer_reserve, rbuf, additional)
+
+    def free(self):
+        return _uniffi_rust_call(_UniffiLib.ffi_quantwave_python_rustbuffer_free, self)
+
+    def __str__(self):
+        return "_UniffiRustBuffer(capacity={}, len={}, data={})".format(
+            self.capacity,
+            self.len,
+            self.data[0:self.len]
+        )
+
+    @contextlib.contextmanager
+    def alloc_with_builder(*args):
+        """Context-manger to allocate a buffer using a _UniffiRustBufferBuilder.
+
+        The allocated buffer will be automatically freed if an error occurs, ensuring that
+        we don't accidentally leak it.
+        """
+        builder = _UniffiRustBufferBuilder()
+        try:
+            yield builder
+        except:
+            builder.discard()
+            raise
+
+    @contextlib.contextmanager
+    def consume_with_stream(self):
+        """Context-manager to consume a buffer using a _UniffiRustBufferStream.
+
+        The _UniffiRustBuffer will be freed once the context-manager exits, ensuring that we don't
+        leak it even if an error occurs.
+        """
+        try:
+            s = _UniffiRustBufferStream.from_rust_buffer(self)
+            yield s
+            if s.remaining() != 0:
+                raise RuntimeError(f"junk data left in buffer at end of consume_with_stream {s.remaining()}")
+        finally:
+            self.free()
+
+    @contextlib.contextmanager
+    def read_with_stream(self):
+        """Context-manager to read a buffer using a _UniffiRustBufferStream.
+
+        This is like consume_with_stream, but doesn't free the buffer afterwards.
+        It should only be used with borrowed `_UniffiRustBuffer` data.
+        """
+        s = _UniffiRustBufferStream.from_rust_buffer(self)
+        yield s
+        if s.remaining() != 0:
+            raise RuntimeError(f"junk data left in buffer at end of read_with_stream {s.remaining()}")
+
+class _UniffiForeignBytes(ctypes.Structure):
+    _fields_ = [
+        ("len", ctypes.c_int32),
+        ("data", ctypes.POINTER(ctypes.c_char)),
+    ]
+
+    def __str__(self):
+        return "_UniffiForeignBytes(len={}, data={})".format(self.len, self.data[0:self.len])
+
+
+class _UniffiRustBufferStream:
+    """
+    Helper for structured reading of bytes from a _UniffiRustBuffer
+    """
+
+    def __init__(self, data, len):
+        self.data = data
+        self.len = len
+        self.offset = 0
+
+    @classmethod
+    def from_rust_buffer(cls, buf):
+        return cls(buf.data, buf.len)
+
+    def remaining(self):
+        return self.len - self.offset
+
+    def _unpack_from(self, size, format):
+        if self.offset + size > self.len:
+            raise InternalError("read past end of rust buffer")
+        value = struct.unpack(format, self.data[self.offset:self.offset+size])[0]
+        self.offset += size
+        return value
+
+    def read(self, size):
+        if self.offset + size > self.len:
+            raise InternalError("read past end of rust buffer")
+        data = self.data[self.offset:self.offset+size]
+        self.offset += size
+        return data
+
+    def read_i8(self):
+        return self._unpack_from(1, ">b")
+
+    def read_u8(self):
+        return self._unpack_from(1, ">B")
+
+    def read_i16(self):
+        return self._unpack_from(2, ">h")
+
+    def read_u16(self):
+        return self._unpack_from(2, ">H")
+
+    def read_i32(self):
+        return self._unpack_from(4, ">i")
+
+    def read_u32(self):
+        return self._unpack_from(4, ">I")
+
+    def read_i64(self):
+        return self._unpack_from(8, ">q")
+
+    def read_u64(self):
+        return self._unpack_from(8, ">Q")
+
+    def read_float(self):
+        v = self._unpack_from(4, ">f")
+        return v
+
+    def read_double(self):
+        return self._unpack_from(8, ">d")
+
+class _UniffiRustBufferBuilder:
+    """
+    Helper for structured writing of bytes into a _UniffiRustBuffer.
+    """
+
+    def __init__(self):
+        self.rbuf = _UniffiRustBuffer.alloc(16)
+        self.rbuf.len = 0
+
+    def finalize(self):
+        rbuf = self.rbuf
+        self.rbuf = None
+        return rbuf
+
+    def discard(self):
+        if self.rbuf is not None:
+            rbuf = self.finalize()
+            rbuf.free()
+
+    @contextlib.contextmanager
+    def _reserve(self, num_bytes):
+        if self.rbuf.len + num_bytes > self.rbuf.capacity:
+            self.rbuf = _UniffiRustBuffer.reserve(self.rbuf, num_bytes)
+        yield None
+        self.rbuf.len += num_bytes
+
+    def _pack_into(self, size, format, value):
+        with self._reserve(size):
+            # XXX TODO: I feel like I should be able to use `struct.pack_into` here but can't figure it out.
+            for i, byte in enumerate(struct.pack(format, value)):
+                self.rbuf.data[self.rbuf.len + i] = byte
+
+    def write(self, value):
+        with self._reserve(len(value)):
+            for i, byte in enumerate(value):
+                self.rbuf.data[self.rbuf.len + i] = byte
+
+    def write_i8(self, v):
+        self._pack_into(1, ">b", v)
+
+    def write_u8(self, v):
+        self._pack_into(1, ">B", v)
+
+    def write_i16(self, v):
+        self._pack_into(2, ">h", v)
+
+    def write_u16(self, v):
+        self._pack_into(2, ">H", v)
+
+    def write_i32(self, v):
+        self._pack_into(4, ">i", v)
+
+    def write_u32(self, v):
+        self._pack_into(4, ">I", v)
+
+    def write_i64(self, v):
+        self._pack_into(8, ">q", v)
+
+    def write_u64(self, v):
+        self._pack_into(8, ">Q", v)
+
+    def write_float(self, v):
+        self._pack_into(4, ">f", v)
+
+    def write_double(self, v):
+        self._pack_into(8, ">d", v)
+
+    def write_c_size_t(self, v):
+        self._pack_into(ctypes.sizeof(ctypes.c_size_t) , "@N", v)
+# A handful of classes and functions to support the generated data structures.
+# This would be a good candidate for isolating in its own ffi-support lib.
+
+class InternalError(Exception):
+    pass
+
+class _UniffiRustCallStatus(ctypes.Structure):
+    """
+    Error runtime.
+    """
+    _fields_ = [
+        ("code", ctypes.c_int8),
+        ("error_buf", _UniffiRustBuffer),
+    ]
+
+    # These match the values from the uniffi::rustcalls module
+    CALL_SUCCESS = 0
+    CALL_ERROR = 1
+    CALL_UNEXPECTED_ERROR = 2
+
+    @staticmethod
+    def default():
+        return _UniffiRustCallStatus(code=_UniffiRustCallStatus.CALL_SUCCESS, error_buf=_UniffiRustBuffer.default())
+
+    def __str__(self):
+        if self.code == _UniffiRustCallStatus.CALL_SUCCESS:
+            return "_UniffiRustCallStatus(CALL_SUCCESS)"
+        elif self.code == _UniffiRustCallStatus.CALL_ERROR:
+            return "_UniffiRustCallStatus(CALL_ERROR)"
+        elif self.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
+            return "_UniffiRustCallStatus(CALL_UNEXPECTED_ERROR)"
+        else:
+            return "_UniffiRustCallStatus(<invalid code>)"
+
+def _uniffi_rust_call(fn, *args):
+    # Call a rust function
+    return _uniffi_rust_call_with_error(None, fn, *args)
+
+def _uniffi_rust_call_with_error(error_ffi_converter, fn, *args):
+    # Call a rust function and handle any errors
+    #
+    # This function is used for rust calls that return Result<> and therefore can set the CALL_ERROR status code.
+    # error_ffi_converter must be set to the _UniffiConverter for the error class that corresponds to the result.
+    call_status = _UniffiRustCallStatus.default()
+
+    args_with_error = args + (ctypes.byref(call_status),)
+    result = fn(*args_with_error)
+    _uniffi_check_call_status(error_ffi_converter, call_status)
+    return result
+
+def _uniffi_check_call_status(error_ffi_converter, call_status):
+    if call_status.code == _UniffiRustCallStatus.CALL_SUCCESS:
+        pass
+    elif call_status.code == _UniffiRustCallStatus.CALL_ERROR:
+        if error_ffi_converter is None:
+            call_status.error_buf.free()
+            raise InternalError("_uniffi_rust_call_with_error: CALL_ERROR, but error_ffi_converter is None")
+        else:
+            raise error_ffi_converter.lift(call_status.error_buf)
+    elif call_status.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
+        # When the rust code sees a panic, it tries to construct a _UniffiRustBuffer
+        # with the message.  But if that code panics, then it just sends back
+        # an empty buffer.
+        if call_status.error_buf.len > 0:
+            msg = _UniffiFfiConverterString.lift(call_status.error_buf)
+        else:
+            msg = "Unknown rust panic"
+        raise InternalError(msg)
+    else:
+        raise InternalError("Invalid _UniffiRustCallStatus code: {}".format(
+            call_status.code))
+
+def _uniffi_trait_interface_call(call_status, make_call, write_return_value):
+    try:
+        return write_return_value(make_call())
+    except Exception as e:
+        call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
+        call_status.error_buf = _UniffiFfiConverterString.lower(repr(e))
+
+def _uniffi_trait_interface_call_with_error(call_status, make_call, write_return_value, error_type, lower_error):
+    try:
+        try:
+            return write_return_value(make_call())
+        except error_type as e:
+            call_status.code = _UniffiRustCallStatus.CALL_ERROR
+            call_status.error_buf = lower_error(e)
+    except Exception as e:
+        call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
+        call_status.error_buf = _UniffiFfiConverterString.lower(repr(e))
+# Initial value and increment amount for handles. 
+# These ensure that Python-generated handles always have the lowest bit set
+_UNIFFI_HANDLEMAP_INITIAL = 1
+_UNIFFI_HANDLEMAP_DELTA = 2
+
+class _UniffiHandleMap:
+    """
+    A map where inserting, getting and removing data is synchronized with a lock.
+    """
+
+    def __init__(self):
+        # type Handle = int
+        self._map = {}  # type: Dict[Handle, Any]
+        self._lock = threading.Lock()
+        self._counter = _UNIFFI_HANDLEMAP_INITIAL
+
+    def insert(self, obj):
+        with self._lock:
+            return self._insert(obj)
+
+    """Low-level insert, this assumes `self._lock` is held."""
+    def _insert(self, obj):
+        handle = self._counter
+        self._counter += _UNIFFI_HANDLEMAP_DELTA
+        self._map[handle] = obj
+        return handle
+
+    def get(self, handle):
+        try:
+            with self._lock:
+                return self._map[handle]
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.get: Invalid handle {handle}")
+
+    def clone(self, handle):
+        try:
+            with self._lock:
+                obj = self._map[handle]
+                return self._insert(obj)
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.clone: Invalid handle {handle}")
+
+    def remove(self, handle):
+        try:
+            with self._lock:
+                return self._map.pop(handle)
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.remove: Invalid handle: {handle}")
+
+    def __len__(self):
+        return len(self._map)
+# Types conforming to `_UniffiConverterPrimitive` pass themselves directly over the FFI.
+class _UniffiConverterPrimitive:
+    @classmethod
+    def lift(cls, value):
+        return value
+
+    @classmethod
+    def lower(cls, value):
+        return value
+
+class _UniffiConverterPrimitiveInt(_UniffiConverterPrimitive):
+    @classmethod
+    def check_lower(cls, value):
+        try:
+            value = value.__index__()
+        except Exception:
+            raise TypeError("'{}' object cannot be interpreted as an integer".format(type(value).__name__))
+        if not isinstance(value, int):
+            raise TypeError("__index__ returned non-int (type {})".format(type(value).__name__))
+        if not cls.VALUE_MIN <= value < cls.VALUE_MAX:
+            raise ValueError("{} requires {} <= value < {}".format(cls.CLASS_NAME, cls.VALUE_MIN, cls.VALUE_MAX))
+
+class _UniffiConverterPrimitiveFloat(_UniffiConverterPrimitive):
+    @classmethod
+    def check_lower(cls, value):
+        try:
+            value = value.__float__()
+        except Exception:
+            raise TypeError("must be real number, not {}".format(type(value).__name__))
+        if not isinstance(value, float):
+            raise TypeError("__float__ returned non-float (type {})".format(type(value).__name__))
+
+# Helper class for wrapper types that will always go through a _UniffiRustBuffer.
+# Classes should inherit from this and implement the `read` and `write` static methods.
+class _UniffiConverterRustBuffer:
+    @classmethod
+    def lift(cls, rbuf):
+        with rbuf.consume_with_stream() as stream:
+            return cls.read(stream)
+
+    @classmethod
+    def lower(cls, value):
+        with _UniffiRustBuffer.alloc_with_builder() as builder:
+            cls.write(value, builder)
+            return builder.finalize()
+
+# Contains loading, initialization code, and the FFI Function declarations.
+# Define some ctypes FFI types that we use in the library
+
+"""
+Function pointer for a Rust task, which a callback function that takes a opaque pointer
+"""
+_UNIFFI_RUST_TASK = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int8)
+
+def _uniffi_future_callback_t(return_type):
+    """
+    Factory function to create callback function types for async functions
+    """
+    return ctypes.CFUNCTYPE(None, ctypes.c_uint64, return_type, _UniffiRustCallStatus)
+
+def _uniffi_load_indirect():
+    """
+    This is how we find and load the dynamic library provided by the component.
+    For now we just look it up by name.
+    """
+    if sys.platform == "darwin":
+        libname = "lib{}.dylib"
+    elif sys.platform.startswith("win"):
+        # As of python3.8, ctypes does not seem to search $PATH when loading DLLs.
+        # We could use `os.add_dll_directory` to configure the search path, but
+        # it doesn't feel right to mess with application-wide settings. Let's
+        # assume that the `.dll` is next to the `.py` file and load by full path.
+        libname = os.path.join(
+            os.path.dirname(__file__),
+            "{}.dll",
+        )
+    else:
+        # Anything else must be an ELF platform - Linux, *BSD, Solaris/illumos
+        libname = "lib{}.so"
+
+    libname = libname.format("quantwave_python")
+    path = os.path.join(os.path.dirname(__file__), libname)
+    lib = ctypes.cdll.LoadLibrary(path)
+    return lib
+
+def _uniffi_check_contract_api_version(lib):
+    # Get the bindings contract version from our ComponentInterface
+    bindings_contract_version = 30
+    # Get the scaffolding contract version by calling the into the dylib
+    scaffolding_contract_version = lib.ffi_quantwave_python_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version:
+        raise InternalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+
+def _uniffi_check_api_checksums(lib):
+    if lib.uniffi_quantwave_python_checksum_func_adx() != 29272:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_aroon() != 19580:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_atr() != 51556:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_bbands() != 8036:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_cci() != 3494:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_dema() != 26054:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_ema() != 37217:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_ichimoku_batch() != 60138:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_kama() != 56018:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_macd() != 813:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_mama() != 14526:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_mom() != 9823:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_roc() != 52035:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_rsi() != 17470:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_sar() != 1260:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_sma() != 65417:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_stoch() != 29426:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_supertrend_batch() != 13144:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_t3() != 2991:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_tema() != 19791:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_willr() != 6232:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_func_wma() != 54822:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_adx_new() != 24369:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_adx_next() != 13949:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_atr_new() != 9842:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_atr_next() != 5508:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_bbands_new() != 19772:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_bbands_next() != 18423:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_cci_new() != 61766:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_cci_next() != 6750:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_ema_new() != 52537:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_ema_next() != 21608:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_ichimoku_new() != 17155:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_ichimoku_next() != 34652:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_kama_new() != 13791:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_kama_next() != 1941:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_macd_new() != 64226:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_macd_next() != 60380:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_mama_new() != 3570:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_mama_next() != 56773:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_rsi_new() != 54433:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_rsi_next() != 36470:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_sar_new() != 55036:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_sar_next() != 13494:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_sma_new() != 549:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_sma_next() != 43956:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_stoch_new() != 16954:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_stoch_next() != 16298:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_supertrend_new() != 33689:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_supertrend_next() != 16495:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_t3_new() != 16265:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_t3_next() != 4066:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_constructor_wma_new() != 20766:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_quantwave_python_checksum_method_wma_next() != 17686:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+
+# A ctypes library to expose the extern-C FFI definitions.
+# This is an implementation detail which will be called internally by the public API.
+
+_UniffiLib = _uniffi_load_indirect()
+_UniffiLib.ffi_quantwave_python_rustbuffer_alloc.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rustbuffer_alloc.restype = _UniffiRustBuffer
+_UniffiLib.ffi_quantwave_python_rustbuffer_from_bytes.argtypes = (
+    _UniffiForeignBytes,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rustbuffer_from_bytes.restype = _UniffiRustBuffer
+_UniffiLib.ffi_quantwave_python_rustbuffer_free.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rustbuffer_free.restype = None
+_UniffiLib.ffi_quantwave_python_rustbuffer_reserve.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rustbuffer_reserve.restype = _UniffiRustBuffer
+_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_int8,
+)
+_UNIFFI_FOREIGN_FUTURE_DROPPED_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,
+)
+class _UniffiForeignFutureDroppedCallbackStruct(ctypes.Structure):
+    _fields_ = [
+        ("handle", ctypes.c_uint64),
+        ("free", _UNIFFI_FOREIGN_FUTURE_DROPPED_CALLBACK),
+    ]
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u8.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u8.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u8.restype = ctypes.c_uint8
+_UniffiLib.ffi_quantwave_python_rust_future_free_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_u8.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i8.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i8.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i8.restype = ctypes.c_int8
+_UniffiLib.ffi_quantwave_python_rust_future_free_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_i8.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u16.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u16.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u16.restype = ctypes.c_uint16
+_UniffiLib.ffi_quantwave_python_rust_future_free_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_u16.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i16.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i16.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i16.restype = ctypes.c_int16
+_UniffiLib.ffi_quantwave_python_rust_future_free_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_i16.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u32.restype = ctypes.c_uint32
+_UniffiLib.ffi_quantwave_python_rust_future_free_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_u32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i32.restype = ctypes.c_int32
+_UniffiLib.ffi_quantwave_python_rust_future_free_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_i32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_u64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_u64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_u64.restype = ctypes.c_uint64
+_UniffiLib.ffi_quantwave_python_rust_future_free_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_u64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_i64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_i64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_i64.restype = ctypes.c_int64
+_UniffiLib.ffi_quantwave_python_rust_future_free_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_i64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_f32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_f32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_f32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_f32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_f32.restype = ctypes.c_float
+_UniffiLib.ffi_quantwave_python_rust_future_free_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_f32.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_f64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_f64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_f64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_f64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_f64.restype = ctypes.c_double
+_UniffiLib.ffi_quantwave_python_rust_future_free_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_f64.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_rust_buffer.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_rust_buffer.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_rust_buffer.restype = _UniffiRustBuffer
+_UniffiLib.ffi_quantwave_python_rust_future_free_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_rust_buffer.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_poll_void.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_poll_void.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_cancel_void.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_complete_void.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_quantwave_python_rust_future_complete_void.restype = None
+_UniffiLib.ffi_quantwave_python_rust_future_free_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_quantwave_python_rust_future_free_void.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_adx.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_adx.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_adx.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_adx.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_atr.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_atr.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_atr.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_atr.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_bbands.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_bbands.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_bbands.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_bbands.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_cci.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_cci.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_cci.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_cci.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_ema.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_ema.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_ema.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_ema.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_ichimoku.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_ichimoku.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_ichimoku.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_ichimoku.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_kama.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_kama.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_kama.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_kama.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_macd.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_macd.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_macd.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_macd.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_mama.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_mama.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_mama.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_mama.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_rsi.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_rsi.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_rsi.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_rsi.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_sar.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_sar.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_sar.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_sar.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_sma.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_sma.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_sma.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_sma.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_stoch.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_stoch.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_stoch.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_stoch.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_supertrend.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_supertrend.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_supertrend.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_supertrend.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_t3.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_t3.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_t3.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_t3.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_clone_wma.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_clone_wma.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_free_wma.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_free_wma.restype = None
+_UniffiLib.uniffi_quantwave_python_fn_func_adx.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_adx.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_aroon.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_aroon.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_atr.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_atr.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_bbands.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_bbands.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_cci.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_cci.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_dema.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_dema.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_ema.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_ema.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_ichimoku_batch.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_ichimoku_batch.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_kama.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_kama.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_macd.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_macd.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_mama.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_mama.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_mom.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_mom.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_roc.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_roc.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_rsi.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_rsi.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_sar.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_sar.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_sma.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_sma.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_stoch.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_stoch.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_supertrend_batch.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_supertrend_batch.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_t3.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_t3.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_tema.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_tema.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_willr.argtypes = (
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_willr.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_func_wma.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_func_wma.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_constructor_adx_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_adx_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_adx_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_adx_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_atr_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_atr_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_atr_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_atr_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_bbands_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_bbands_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_bbands_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_bbands_next.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_constructor_cci_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_cci_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_cci_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_cci_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_ema_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_ema_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_ema_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_ema_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_ichimoku_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_ichimoku_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_ichimoku_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_ichimoku_next.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_constructor_kama_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_kama_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_kama_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_kama_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_macd_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_macd_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_macd_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_macd_next.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_constructor_mama_new.argtypes = (
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_mama_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_mama_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_mama_next.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_constructor_rsi_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_rsi_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_rsi_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_rsi_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_sar_new.argtypes = (
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_sar_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_sar_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_sar_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_sma_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_sma_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_sma_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_sma_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_stoch_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_stoch_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_stoch_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_stoch_next.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_constructor_supertrend_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_supertrend_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_supertrend_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_supertrend_next.restype = _UniffiRustBuffer
+_UniffiLib.uniffi_quantwave_python_fn_constructor_t3_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_t3_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_t3_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_t3_next.restype = ctypes.c_double
+_UniffiLib.uniffi_quantwave_python_fn_constructor_wma_new.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_constructor_wma_new.restype = ctypes.c_uint64
+_UniffiLib.uniffi_quantwave_python_fn_method_wma_next.argtypes = (
+    ctypes.c_uint64,
+    ctypes.c_double,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_quantwave_python_fn_method_wma_next.restype = ctypes.c_double
+_UniffiLib.ffi_quantwave_python_uniffi_contract_version.argtypes = (
+)
+_UniffiLib.ffi_quantwave_python_uniffi_contract_version.restype = ctypes.c_uint32
+_UniffiLib.uniffi_quantwave_python_checksum_func_adx.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_adx.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_aroon.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_aroon.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_atr.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_atr.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_bbands.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_bbands.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_cci.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_cci.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_dema.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_dema.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_ema.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_ema.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_ichimoku_batch.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_ichimoku_batch.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_kama.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_kama.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_macd.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_macd.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_mama.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_mama.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_mom.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_mom.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_roc.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_roc.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_rsi.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_rsi.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_sar.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_sar.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_sma.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_sma.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_stoch.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_stoch.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_supertrend_batch.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_supertrend_batch.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_t3.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_t3.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_tema.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_tema.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_willr.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_willr.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_func_wma.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_func_wma.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_adx_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_adx_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_adx_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_adx_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_atr_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_atr_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_atr_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_atr_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_bbands_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_bbands_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_bbands_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_bbands_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_cci_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_cci_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_cci_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_cci_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_ema_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_ema_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_ema_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_ema_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_ichimoku_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_ichimoku_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_ichimoku_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_ichimoku_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_kama_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_kama_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_kama_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_kama_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_macd_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_macd_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_macd_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_macd_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_mama_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_mama_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_mama_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_mama_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_rsi_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_rsi_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_rsi_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_rsi_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_sar_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_sar_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_sar_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_sar_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_sma_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_sma_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_sma_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_sma_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_stoch_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_stoch_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_stoch_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_stoch_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_supertrend_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_supertrend_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_supertrend_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_supertrend_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_t3_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_t3_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_t3_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_t3_next.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_wma_new.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_constructor_wma_new.restype = ctypes.c_uint16
+_UniffiLib.uniffi_quantwave_python_checksum_method_wma_next.argtypes = (
+)
+_UniffiLib.uniffi_quantwave_python_checksum_method_wma_next.restype = ctypes.c_uint16
+
+_uniffi_check_contract_api_version(_UniffiLib)
+# _uniffi_check_api_checksums(_UniffiLib)
+
+
+
+# Public interface members begin here.
+
+
+class _UniffiFfiConverterFloat64(_UniffiConverterPrimitiveFloat):
+    @staticmethod
+    def read(buf):
+        return buf.read_double()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_double(value)
+
+@dataclass
+class AroonResult:
+    def __init__(self, *, up:float, down:float):
+        self.up = up
+        self.down = down
+        
+        
+
+    
+    def __str__(self):
+        return "AroonResult(up={}, down={})".format(self.up, self.down)
+    def __eq__(self, other):
+        if self.up != other.up:
+            return False
+        if self.down != other.down:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeAroonResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return AroonResult(
+            up=_UniffiFfiConverterFloat64.read(buf),
+            down=_UniffiFfiConverterFloat64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat64.check_lower(value.up)
+        _UniffiFfiConverterFloat64.check_lower(value.down)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat64.write(value.up, buf)
+        _UniffiFfiConverterFloat64.write(value.down, buf)
+
+@dataclass
+class BbandsResult:
+    def __init__(self, *, upper:float, middle:float, lower:float):
+        self.upper = upper
+        self.middle = middle
+        self.lower = lower
+        
+        
+
+    
+    def __str__(self):
+        return "BbandsResult(upper={}, middle={}, lower={})".format(self.upper, self.middle, self.lower)
+    def __eq__(self, other):
+        if self.upper != other.upper:
+            return False
+        if self.middle != other.middle:
+            return False
+        if self.lower != other.lower:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeBbandsResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return BbandsResult(
+            upper=_UniffiFfiConverterFloat64.read(buf),
+            middle=_UniffiFfiConverterFloat64.read(buf),
+            lower=_UniffiFfiConverterFloat64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat64.check_lower(value.upper)
+        _UniffiFfiConverterFloat64.check_lower(value.middle)
+        _UniffiFfiConverterFloat64.check_lower(value.lower)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat64.write(value.upper, buf)
+        _UniffiFfiConverterFloat64.write(value.middle, buf)
+        _UniffiFfiConverterFloat64.write(value.lower, buf)
+
+@dataclass
+class IchimokuResult:
+    def __init__(self, *, tenkan:float, kijun:float, senkou_a:float, senkou_b:float):
+        self.tenkan = tenkan
+        self.kijun = kijun
+        self.senkou_a = senkou_a
+        self.senkou_b = senkou_b
+        
+        
+
+    
+    def __str__(self):
+        return "IchimokuResult(tenkan={}, kijun={}, senkou_a={}, senkou_b={})".format(self.tenkan, self.kijun, self.senkou_a, self.senkou_b)
+    def __eq__(self, other):
+        if self.tenkan != other.tenkan:
+            return False
+        if self.kijun != other.kijun:
+            return False
+        if self.senkou_a != other.senkou_a:
+            return False
+        if self.senkou_b != other.senkou_b:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeIchimokuResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return IchimokuResult(
+            tenkan=_UniffiFfiConverterFloat64.read(buf),
+            kijun=_UniffiFfiConverterFloat64.read(buf),
+            senkou_a=_UniffiFfiConverterFloat64.read(buf),
+            senkou_b=_UniffiFfiConverterFloat64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat64.check_lower(value.tenkan)
+        _UniffiFfiConverterFloat64.check_lower(value.kijun)
+        _UniffiFfiConverterFloat64.check_lower(value.senkou_a)
+        _UniffiFfiConverterFloat64.check_lower(value.senkou_b)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat64.write(value.tenkan, buf)
+        _UniffiFfiConverterFloat64.write(value.kijun, buf)
+        _UniffiFfiConverterFloat64.write(value.senkou_a, buf)
+        _UniffiFfiConverterFloat64.write(value.senkou_b, buf)
+
+@dataclass
+class MacdResult:
+    def __init__(self, *, macd:float, signal:float, histogram:float):
+        self.macd = macd
+        self.signal = signal
+        self.histogram = histogram
+        
+        
+
+    
+    def __str__(self):
+        return "MacdResult(macd={}, signal={}, histogram={})".format(self.macd, self.signal, self.histogram)
+    def __eq__(self, other):
+        if self.macd != other.macd:
+            return False
+        if self.signal != other.signal:
+            return False
+        if self.histogram != other.histogram:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeMacdResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return MacdResult(
+            macd=_UniffiFfiConverterFloat64.read(buf),
+            signal=_UniffiFfiConverterFloat64.read(buf),
+            histogram=_UniffiFfiConverterFloat64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat64.check_lower(value.macd)
+        _UniffiFfiConverterFloat64.check_lower(value.signal)
+        _UniffiFfiConverterFloat64.check_lower(value.histogram)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat64.write(value.macd, buf)
+        _UniffiFfiConverterFloat64.write(value.signal, buf)
+        _UniffiFfiConverterFloat64.write(value.histogram, buf)
+
+@dataclass
+class MamaResult:
+    def __init__(self, *, mama:float, fama:float):
+        self.mama = mama
+        self.fama = fama
+        
+        
+
+    
+    def __str__(self):
+        return "MamaResult(mama={}, fama={})".format(self.mama, self.fama)
+    def __eq__(self, other):
+        if self.mama != other.mama:
+            return False
+        if self.fama != other.fama:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeMamaResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return MamaResult(
+            mama=_UniffiFfiConverterFloat64.read(buf),
+            fama=_UniffiFfiConverterFloat64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat64.check_lower(value.mama)
+        _UniffiFfiConverterFloat64.check_lower(value.fama)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat64.write(value.mama, buf)
+        _UniffiFfiConverterFloat64.write(value.fama, buf)
+
+@dataclass
+class StochResult:
+    def __init__(self, *, k:float, d:float):
+        self.k = k
+        self.d = d
+        
+        
+
+    
+    def __str__(self):
+        return "StochResult(k={}, d={})".format(self.k, self.d)
+    def __eq__(self, other):
+        if self.k != other.k:
+            return False
+        if self.d != other.d:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeStochResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return StochResult(
+            k=_UniffiFfiConverterFloat64.read(buf),
+            d=_UniffiFfiConverterFloat64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat64.check_lower(value.k)
+        _UniffiFfiConverterFloat64.check_lower(value.d)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat64.write(value.k, buf)
+        _UniffiFfiConverterFloat64.write(value.d, buf)
+
+class _UniffiFfiConverterInt8(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "i8"
+    VALUE_MIN = -2**7
+    VALUE_MAX = 2**7
+
+    @staticmethod
+    def read(buf):
+        return buf.read_i8()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_i8(value)
+
+@dataclass
+class SuperTrendResult:
+    def __init__(self, *, value:float, direction:int):
+        self.value = value
+        self.direction = direction
+        
+        
+
+    
+    def __str__(self):
+        return "SuperTrendResult(value={}, direction={})".format(self.value, self.direction)
+    def __eq__(self, other):
+        if self.value != other.value:
+            return False
+        if self.direction != other.direction:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeSuperTrendResult(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return SuperTrendResult(
+            value=_UniffiFfiConverterFloat64.read(buf),
+            direction=_UniffiFfiConverterInt8.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterFloat64.check_lower(value.value)
+        _UniffiFfiConverterInt8.check_lower(value.direction)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterFloat64.write(value.value, buf)
+        _UniffiFfiConverterInt8.write(value.direction, buf)
+
+
+class AdxProtocol(typing.Protocol):
+    
+    def next(self, high: float,low: float,close: float) -> float:
+        raise NotImplementedError
+
+class Adx(AdxProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeAdx.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_adx_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_adx, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_adx, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, high: float,low: float,close: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(high)
+
+        _UniffiFfiConverterFloat64.check_lower(low)
+
+        _UniffiFfiConverterFloat64.check_lower(close)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(high),
+            _UniffiFfiConverterFloat64.lower(low),
+            _UniffiFfiConverterFloat64.lower(close),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_adx_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeAdx:
+    @staticmethod
+    def lift(value: int) -> Adx:
+        return Adx._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Adx):
+        if not isinstance(value, Adx):
+            raise TypeError("Expected Adx instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Adx) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Adx:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Adx, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class AtrProtocol(typing.Protocol):
+    
+    def next(self, high: float,low: float,close: float) -> float:
+        raise NotImplementedError
+
+class Atr(AtrProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeAtr.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_atr_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_atr, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_atr, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, high: float,low: float,close: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(high)
+
+        _UniffiFfiConverterFloat64.check_lower(low)
+
+        _UniffiFfiConverterFloat64.check_lower(close)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(high),
+            _UniffiFfiConverterFloat64.lower(low),
+            _UniffiFfiConverterFloat64.lower(close),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_atr_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeAtr:
+    @staticmethod
+    def lift(value: int) -> Atr:
+        return Atr._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Atr):
+        if not isinstance(value, Atr):
+            raise TypeError("Expected Atr instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Atr) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Atr:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Atr, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class BbandsProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> BbandsResult:
+        raise NotImplementedError
+
+class Bbands(BbandsProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int,nbdevup: float,nbdevdn: float):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+
+        _UniffiFfiConverterFloat64.check_lower(nbdevup)
+
+        _UniffiFfiConverterFloat64.check_lower(nbdevdn)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+            _UniffiFfiConverterFloat64.lower(nbdevup),
+            _UniffiFfiConverterFloat64.lower(nbdevdn),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeBbands.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_bbands_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_bbands, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_bbands, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> BbandsResult:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeBbandsResult.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_bbands_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeBbands:
+    @staticmethod
+    def lift(value: int) -> Bbands:
+        return Bbands._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Bbands):
+        if not isinstance(value, Bbands):
+            raise TypeError("Expected Bbands instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Bbands) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Bbands:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Bbands, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class CciProtocol(typing.Protocol):
+    
+    def next(self, high: float,low: float,close: float) -> float:
+        raise NotImplementedError
+
+class Cci(CciProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeCci.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_cci_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_cci, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_cci, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, high: float,low: float,close: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(high)
+
+        _UniffiFfiConverterFloat64.check_lower(low)
+
+        _UniffiFfiConverterFloat64.check_lower(close)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(high),
+            _UniffiFfiConverterFloat64.lower(low),
+            _UniffiFfiConverterFloat64.lower(close),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_cci_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeCci:
+    @staticmethod
+    def lift(value: int) -> Cci:
+        return Cci._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Cci):
+        if not isinstance(value, Cci):
+            raise TypeError("Expected Cci instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Cci) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Cci:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Cci, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class EmaProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> float:
+        raise NotImplementedError
+
+class Ema(EmaProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeEma.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_ema_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_ema, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_ema, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_ema_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeEma:
+    @staticmethod
+    def lift(value: int) -> Ema:
+        return Ema._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Ema):
+        if not isinstance(value, Ema):
+            raise TypeError("Expected Ema instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Ema) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Ema:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Ema, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class IchimokuProtocol(typing.Protocol):
+    
+    def next(self, high: float,low: float) -> IchimokuResult:
+        raise NotImplementedError
+
+class Ichimoku(IchimokuProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, tenkan: int,kijun: int,senkou_b: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(tenkan)
+
+        _UniffiFfiConverterUInt64.check_lower(kijun)
+
+        _UniffiFfiConverterUInt64.check_lower(senkou_b)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(tenkan),
+            _UniffiFfiConverterUInt64.lower(kijun),
+            _UniffiFfiConverterUInt64.lower(senkou_b),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeIchimoku.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_ichimoku_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_ichimoku, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_ichimoku, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, high: float,low: float) -> IchimokuResult:
+        
+        _UniffiFfiConverterFloat64.check_lower(high)
+
+        _UniffiFfiConverterFloat64.check_lower(low)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(high),
+            _UniffiFfiConverterFloat64.lower(low),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeIchimokuResult.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_ichimoku_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeIchimoku:
+    @staticmethod
+    def lift(value: int) -> Ichimoku:
+        return Ichimoku._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Ichimoku):
+        if not isinstance(value, Ichimoku):
+            raise TypeError("Expected Ichimoku instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Ichimoku) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Ichimoku:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Ichimoku, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class KamaProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> float:
+        raise NotImplementedError
+
+class Kama(KamaProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeKama.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_kama_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_kama, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_kama, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_kama_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeKama:
+    @staticmethod
+    def lift(value: int) -> Kama:
+        return Kama._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Kama):
+        if not isinstance(value, Kama):
+            raise TypeError("Expected Kama instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Kama) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Kama:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Kama, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class MacdProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> MacdResult:
+        raise NotImplementedError
+
+class Macd(MacdProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, fast: int,slow: int,signal: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(fast)
+
+        _UniffiFfiConverterUInt64.check_lower(slow)
+
+        _UniffiFfiConverterUInt64.check_lower(signal)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(fast),
+            _UniffiFfiConverterUInt64.lower(slow),
+            _UniffiFfiConverterUInt64.lower(signal),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeMacd.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_macd_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_macd, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_macd, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> MacdResult:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeMacdResult.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_macd_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeMacd:
+    @staticmethod
+    def lift(value: int) -> Macd:
+        return Macd._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Macd):
+        if not isinstance(value, Macd):
+            raise TypeError("Expected Macd instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Macd) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Macd:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Macd, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class MamaProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> MamaResult:
+        raise NotImplementedError
+
+class Mama(MamaProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, fastlimit: float,slowlimit: float):
+        
+        _UniffiFfiConverterFloat64.check_lower(fastlimit)
+
+        _UniffiFfiConverterFloat64.check_lower(slowlimit)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterFloat64.lower(fastlimit),
+            _UniffiFfiConverterFloat64.lower(slowlimit),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeMama.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_mama_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_mama, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_mama, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> MamaResult:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeMamaResult.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_mama_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeMama:
+    @staticmethod
+    def lift(value: int) -> Mama:
+        return Mama._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Mama):
+        if not isinstance(value, Mama):
+            raise TypeError("Expected Mama instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Mama) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Mama:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Mama, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class RsiProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> float:
+        raise NotImplementedError
+
+class Rsi(RsiProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeRsi.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_rsi_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_rsi, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_rsi, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_rsi_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeRsi:
+    @staticmethod
+    def lift(value: int) -> Rsi:
+        return Rsi._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Rsi):
+        if not isinstance(value, Rsi):
+            raise TypeError("Expected Rsi instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Rsi) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Rsi:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Rsi, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class SarProtocol(typing.Protocol):
+    
+    def next(self, high: float,low: float) -> float:
+        raise NotImplementedError
+
+class Sar(SarProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, acceleration: float,maximum: float):
+        
+        _UniffiFfiConverterFloat64.check_lower(acceleration)
+
+        _UniffiFfiConverterFloat64.check_lower(maximum)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterFloat64.lower(acceleration),
+            _UniffiFfiConverterFloat64.lower(maximum),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeSar.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_sar_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_sar, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_sar, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, high: float,low: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(high)
+
+        _UniffiFfiConverterFloat64.check_lower(low)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(high),
+            _UniffiFfiConverterFloat64.lower(low),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_sar_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeSar:
+    @staticmethod
+    def lift(value: int) -> Sar:
+        return Sar._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Sar):
+        if not isinstance(value, Sar):
+            raise TypeError("Expected Sar instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Sar) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Sar:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Sar, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class SmaProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> float:
+        raise NotImplementedError
+
+class Sma(SmaProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeSma.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_sma_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_sma, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_sma, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_sma_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeSma:
+    @staticmethod
+    def lift(value: int) -> Sma:
+        return Sma._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Sma):
+        if not isinstance(value, Sma):
+            raise TypeError("Expected Sma instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Sma) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Sma:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Sma, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class StochProtocol(typing.Protocol):
+    
+    def next(self, high: float,low: float,close: float) -> StochResult:
+        raise NotImplementedError
+
+class Stoch(StochProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, fastk: int,slowk: int,slowd: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(fastk)
+
+        _UniffiFfiConverterUInt64.check_lower(slowk)
+
+        _UniffiFfiConverterUInt64.check_lower(slowd)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(fastk),
+            _UniffiFfiConverterUInt64.lower(slowk),
+            _UniffiFfiConverterUInt64.lower(slowd),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeStoch.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_stoch_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_stoch, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_stoch, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, high: float,low: float,close: float) -> StochResult:
+        
+        _UniffiFfiConverterFloat64.check_lower(high)
+
+        _UniffiFfiConverterFloat64.check_lower(low)
+
+        _UniffiFfiConverterFloat64.check_lower(close)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(high),
+            _UniffiFfiConverterFloat64.lower(low),
+            _UniffiFfiConverterFloat64.lower(close),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeStochResult.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_stoch_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeStoch:
+    @staticmethod
+    def lift(value: int) -> Stoch:
+        return Stoch._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Stoch):
+        if not isinstance(value, Stoch):
+            raise TypeError("Expected Stoch instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Stoch) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Stoch:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Stoch, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class SuperTrendProtocol(typing.Protocol):
+    
+    def next(self, high: float,low: float,close: float) -> SuperTrendResult:
+        raise NotImplementedError
+
+class SuperTrend(SuperTrendProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int,multiplier: float):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+
+        _UniffiFfiConverterFloat64.check_lower(multiplier)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+            _UniffiFfiConverterFloat64.lower(multiplier),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeSuperTrend.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_supertrend_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_supertrend, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_supertrend, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, high: float,low: float,close: float) -> SuperTrendResult:
+        
+        _UniffiFfiConverterFloat64.check_lower(high)
+
+        _UniffiFfiConverterFloat64.check_lower(low)
+
+        _UniffiFfiConverterFloat64.check_lower(close)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(high),
+            _UniffiFfiConverterFloat64.lower(low),
+            _UniffiFfiConverterFloat64.lower(close),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeSuperTrendResult.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_supertrend_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeSuperTrend:
+    @staticmethod
+    def lift(value: int) -> SuperTrend:
+        return SuperTrend._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: SuperTrend):
+        if not isinstance(value, SuperTrend):
+            raise TypeError("Expected SuperTrend instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: SuperTrend) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> SuperTrend:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: SuperTrend, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class T3Protocol(typing.Protocol):
+    
+    def next(self, input: float) -> float:
+        raise NotImplementedError
+
+class T3(T3Protocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int,v_factor: float):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+
+        _UniffiFfiConverterFloat64.check_lower(v_factor)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+            _UniffiFfiConverterFloat64.lower(v_factor),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeT3.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_t3_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_t3, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_t3, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_t3_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeT3:
+    @staticmethod
+    def lift(value: int) -> T3:
+        return T3._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: T3):
+        if not isinstance(value, T3):
+            raise TypeError("Expected T3 instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: T3) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> T3:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: T3, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class WmaProtocol(typing.Protocol):
+    
+    def next(self, input: float) -> float:
+        raise NotImplementedError
+
+class Wma(WmaProtocol):
+    
+    _handle: ctypes.c_uint64
+    def __init__(self, period: int):
+        
+        _UniffiFfiConverterUInt64.check_lower(period)
+        _uniffi_lowered_args = (
+            _UniffiFfiConverterUInt64.lower(period),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterTypeWma.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_constructor_wma_new,
+            *_uniffi_lowered_args,
+        )
+        self._handle = _uniffi_ffi_result
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_free_wma, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_quantwave_python_fn_clone_wma, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+    def next(self, input: float) -> float:
+        
+        _UniffiFfiConverterFloat64.check_lower(input)
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+            _UniffiFfiConverterFloat64.lower(input),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterFloat64.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_quantwave_python_fn_method_wma_next,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeWma:
+    @staticmethod
+    def lift(value: int) -> Wma:
+        return Wma._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: Wma):
+        if not isinstance(value, Wma):
+            raise TypeError("Expected Wma instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: Wma) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> Wma:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: Wma, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+class _UniffiFfiConverterSequenceFloat64(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterFloat64.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterFloat64.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterFloat64.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterUInt64(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "u64"
+    VALUE_MIN = 0
+    VALUE_MAX = 2**64
+
+    @staticmethod
+    def read(buf):
+        return buf.read_u64()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_u64(value)
+
+class _UniffiFfiConverterSequenceTypeAroonResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeAroonResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeAroonResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeAroonResult.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterSequenceTypeBbandsResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeBbandsResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeBbandsResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeBbandsResult.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterSequenceTypeIchimokuResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeIchimokuResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeIchimokuResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeIchimokuResult.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterSequenceTypeMacdResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeMacdResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeMacdResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeMacdResult.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterSequenceTypeMamaResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeMamaResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeMamaResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeMamaResult.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterSequenceTypeStochResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeStochResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeStochResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeStochResult.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterSequenceTypeSuperTrendResult(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        for item in value:
+            _UniffiFfiConverterTypeSuperTrendResult.check_lower(item)
+
+    @classmethod
+    def write(cls, value, buf):
+        items = len(value)
+        buf.write_i32(items)
+        for item in value:
+            _UniffiFfiConverterTypeSuperTrendResult.write(item, buf)
+
+    @classmethod
+    def read(cls, buf):
+        count = buf.read_i32()
+        if count < 0:
+            raise InternalError("Unexpected negative sequence length")
+
+        return [
+            _UniffiFfiConverterTypeSuperTrendResult.read(buf) for i in range(count)
+        ]
+
+class _UniffiFfiConverterString:
+    @staticmethod
+    def check_lower(value):
+        if not isinstance(value, str):
+            raise TypeError("argument must be str, not {}".format(type(value).__name__))
+        return value
+
+    @staticmethod
+    def read(buf):
+        size = buf.read_i32()
+        if size < 0:
+            raise InternalError("Unexpected negative string length")
+        utf8_bytes = buf.read(size)
+        return utf8_bytes.decode("utf-8")
+
+    @staticmethod
+    def write(value, buf):
+        utf8_bytes = value.encode("utf-8")
+        buf.write_i32(len(utf8_bytes))
+        buf.write(utf8_bytes)
+
+    @staticmethod
+    def lift(buf):
+        with buf.consume_with_stream() as stream:
+            return stream.read(stream.remaining()).decode("utf-8")
+
+    @staticmethod
+    def lower(value):
+        with _UniffiRustBuffer.alloc_with_builder() as builder:
+            builder.write(value.encode("utf-8"))
+            return builder.finalize()
+def adx(high: typing.List[float],low: typing.List[float],close: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(close)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterSequenceFloat64.lower(close),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_adx,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def aroon(high: typing.List[float],low: typing.List[float],period: int) -> typing.List[AroonResult]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceTypeAroonResult.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_aroon,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def atr(high: typing.List[float],low: typing.List[float],close: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(close)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterSequenceFloat64.lower(close),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_atr,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def bbands(series: typing.List[float],period: int,nbdevup: float,nbdevdn: float) -> typing.List[BbandsResult]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+
+    _UniffiFfiConverterFloat64.check_lower(nbdevup)
+
+    _UniffiFfiConverterFloat64.check_lower(nbdevdn)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+        _UniffiFfiConverterFloat64.lower(nbdevup),
+        _UniffiFfiConverterFloat64.lower(nbdevdn),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceTypeBbandsResult.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_bbands,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def cci(high: typing.List[float],low: typing.List[float],close: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(close)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterSequenceFloat64.lower(close),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_cci,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def dema(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_dema,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def ema(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_ema,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def ichimoku_batch(high: typing.List[float],low: typing.List[float],tenkan: int,kijun: int,senkou_b: int) -> typing.List[IchimokuResult]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterUInt64.check_lower(tenkan)
+
+    _UniffiFfiConverterUInt64.check_lower(kijun)
+
+    _UniffiFfiConverterUInt64.check_lower(senkou_b)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterUInt64.lower(tenkan),
+        _UniffiFfiConverterUInt64.lower(kijun),
+        _UniffiFfiConverterUInt64.lower(senkou_b),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceTypeIchimokuResult.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_ichimoku_batch,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def kama(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_kama,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def macd(series: typing.List[float],fast_period: int,slow_period: int,signal_period: int) -> typing.List[MacdResult]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(fast_period)
+
+    _UniffiFfiConverterUInt64.check_lower(slow_period)
+
+    _UniffiFfiConverterUInt64.check_lower(signal_period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(fast_period),
+        _UniffiFfiConverterUInt64.lower(slow_period),
+        _UniffiFfiConverterUInt64.lower(signal_period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceTypeMacdResult.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_macd,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def mama(series: typing.List[float],fastlimit: float,slowlimit: float) -> typing.List[MamaResult]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterFloat64.check_lower(fastlimit)
+
+    _UniffiFfiConverterFloat64.check_lower(slowlimit)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterFloat64.lower(fastlimit),
+        _UniffiFfiConverterFloat64.lower(slowlimit),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceTypeMamaResult.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_mama,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def mom(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_mom,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def roc(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_roc,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def rsi(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_rsi,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def sar(high: typing.List[float],low: typing.List[float],acceleration: float,maximum: float) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterFloat64.check_lower(acceleration)
+
+    _UniffiFfiConverterFloat64.check_lower(maximum)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterFloat64.lower(acceleration),
+        _UniffiFfiConverterFloat64.lower(maximum),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_sar,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def sma(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_sma,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def stoch(high: typing.List[float],low: typing.List[float],close: typing.List[float],fastk_period: int,slowk_period: int,slowd_period: int) -> typing.List[StochResult]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(close)
+
+    _UniffiFfiConverterUInt64.check_lower(fastk_period)
+
+    _UniffiFfiConverterUInt64.check_lower(slowk_period)
+
+    _UniffiFfiConverterUInt64.check_lower(slowd_period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterSequenceFloat64.lower(close),
+        _UniffiFfiConverterUInt64.lower(fastk_period),
+        _UniffiFfiConverterUInt64.lower(slowk_period),
+        _UniffiFfiConverterUInt64.lower(slowd_period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceTypeStochResult.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_stoch,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def supertrend_batch(high: typing.List[float],low: typing.List[float],close: typing.List[float],period: int,multiplier: float) -> typing.List[SuperTrendResult]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(close)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+
+    _UniffiFfiConverterFloat64.check_lower(multiplier)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterSequenceFloat64.lower(close),
+        _UniffiFfiConverterUInt64.lower(period),
+        _UniffiFfiConverterFloat64.lower(multiplier),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceTypeSuperTrendResult.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_supertrend_batch,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def t3(series: typing.List[float],period: int,v_factor: float) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+
+    _UniffiFfiConverterFloat64.check_lower(v_factor)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+        _UniffiFfiConverterFloat64.lower(v_factor),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_t3,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def tema(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_tema,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def willr(high: typing.List[float],low: typing.List[float],close: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(high)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(low)
+
+    _UniffiFfiConverterSequenceFloat64.check_lower(close)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(high),
+        _UniffiFfiConverterSequenceFloat64.lower(low),
+        _UniffiFfiConverterSequenceFloat64.lower(close),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_willr,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+def wma(series: typing.List[float],period: int) -> typing.List[float]:
+    
+    _UniffiFfiConverterSequenceFloat64.check_lower(series)
+
+    _UniffiFfiConverterUInt64.check_lower(period)
+    _uniffi_lowered_args = (
+        _UniffiFfiConverterSequenceFloat64.lower(series),
+        _UniffiFfiConverterUInt64.lower(period),
+    )
+    _uniffi_lift_return = _UniffiFfiConverterSequenceFloat64.lift
+    _uniffi_error_converter = None
+    _uniffi_ffi_result = _uniffi_rust_call_with_error(
+        _uniffi_error_converter,
+        _UniffiLib.uniffi_quantwave_python_fn_func_wma,
+        *_uniffi_lowered_args,
+    )
+    return _uniffi_lift_return(_uniffi_ffi_result)
+
+__all__ = [
+    "InternalError",
+    "AroonResult",
+    "BbandsResult",
+    "IchimokuResult",
+    "MacdResult",
+    "MamaResult",
+    "StochResult",
+    "SuperTrendResult",
+    "adx",
+    "aroon",
+    "atr",
+    "bbands",
+    "cci",
+    "dema",
+    "ema",
+    "ichimoku_batch",
+    "kama",
+    "macd",
+    "mama",
+    "mom",
+    "roc",
+    "rsi",
+    "sar",
+    "sma",
+    "stoch",
+    "supertrend_batch",
+    "t3",
+    "tema",
+    "willr",
+    "wma",
+    "Adx",
+    "AdxProtocol",
+    "Atr",
+    "AtrProtocol",
+    "Bbands",
+    "BbandsProtocol",
+    "Cci",
+    "CciProtocol",
+    "Ema",
+    "EmaProtocol",
+    "Ichimoku",
+    "IchimokuProtocol",
+    "Kama",
+    "KamaProtocol",
+    "Macd",
+    "MacdProtocol",
+    "Mama",
+    "MamaProtocol",
+    "Rsi",
+    "RsiProtocol",
+    "Sar",
+    "SarProtocol",
+    "Sma",
+    "SmaProtocol",
+    "Stoch",
+    "StochProtocol",
+    "SuperTrend",
+    "SuperTrendProtocol",
+    "T3",
+    "T3Protocol",
+    "Wma",
+    "WmaProtocol",
+]