native/ffi_types library

Classes

RacAudioFormat

Audio format enumeration (rac_audio_format_enum_t)

RacCapability

Capability types supported by backends (rac_capability_t)

RacDevice

Device type for backend execution (rac_device_t)

RacLlmLlamacppConfigStruct

LlamaCPP config struct matching rac_llm_llamacpp_config_t

RacLlmOptionsStruct

LLM options struct matching rac_llm_options_t

RacLlmResultStruct

LLM result struct matching rac_llm_result_t

RacLogLevel

Log level for logging callback (rac_log_level_t)

RacMemoryInfoStruct

Memory info struct matching rac_memory_info_t

RacPlatformAdapterStruct

Platform adapter struct matching rac_platform_adapter_t Note: This is a complex struct - for simplicity we use Pointer

RacResultCode

Error codes matching rac_error.h

RacSpeechActivity

Speech activity event type (rac_speech_activity_t)

RacSttOnnxConfigStruct

STT ONNX config struct matching rac_stt_onnx_config_t

RacSttOnnxResultStruct

STT ONNX result struct matching rac_stt_onnx_result_t

RacTtsOnnxConfigStruct

TTS ONNX config struct matching rac_tts_onnx_config_t

RacTtsOnnxResultStruct

TTS ONNX result struct matching rac_tts_onnx_result_t

RacVadOnnxConfigStruct

VAD ONNX config struct matching rac_vad_onnx_config_t

RacVadOnnxResultStruct

VAD ONNX result struct matching rac_vad_onnx_result_t

RacVersionStruct

Version info struct matching rac_version_t

Constants

RAC_FALSE → const int

RAC_SUCCESS → const int

RAC success value

RAC_TRUE → const int

RAC boolean values

Typedefs

RaBackendHandle = RacHandle

Backward compatibility: old ra_* types map to new rac_* types

RacAllocDart = Pointer<Void> Function(int size)

RacAllocNative = Pointer<Void> Function(IntPtr size)

void* rac_alloc(size_t size)

RacBackendLlamacppRegisterDart = int Function()

RacBackendLlamacppRegisterNative = Int32 Function()

rac_result_t rac_backend_llamacpp_register(void)

RacBackendLlamacppUnregisterDart = int Function()

RacBackendLlamacppUnregisterNative = Int32 Function()

rac_result_t rac_backend_llamacpp_unregister(void)

RacBool = Int32

Boolean type for C compatibility (rac_bool_t)

RacConfigureLoggingDart = int Function(int environment)

RacConfigureLoggingNative = Int32 Function(Int32 environment)

rac_result_t rac_configure_logging(rac_environment_t environment)

RacErrorClearDetailsDart = void Function()

RacErrorClearDetailsNative = Void Function()

void rac_error_clear_details(void)

RacErrorGetDetailsDart = Pointer<Utf8> Function()

RacErrorGetDetailsNative = Pointer<Utf8> Function()

const char* rac_error_get_details(void)

RacErrorMessageDart = Pointer<Utf8> Function(int errorCode)

RacErrorMessageNative = Pointer<Utf8> Function(Int32 errorCode)

const char* rac_error_message(rac_result_t error_code)

RacErrorSetDetailsDart = void Function(Pointer<Utf8> details)

RacErrorSetDetailsNative = Void Function(Pointer<Utf8> details)

void rac_error_set_details(const char* details)

RacFileDeleteCallbackNative = Int32 Function(Pointer<Utf8> path, Pointer<Void> userData)

File delete callback: rac_result_t (file_delete)(const char path, void* user_data)

RacFileExistsCallbackNative = Int32 Function(Pointer<Utf8> path, Pointer<Void> userData)

File exists callback: rac_bool_t (file_exists)(const char path, void* user_data)

RacFileReadCallbackNative = Int32 Function(Pointer<Utf8> path, Pointer<Pointer<Void>> outData, Pointer<IntPtr> outSize, Pointer<Void> userData)

File read callback: rac_result_t (file_read)(const char path, void** out_data, size_t* out_size, void* user_data)

RacFileWriteCallbackNative = Int32 Function(Pointer<Utf8> path, Pointer<Void> data, IntPtr size, Pointer<Void> userData)

File write callback: rac_result_t (file_write)(const char path, const void* data, size_t size, void* user_data)

RacFreeDart = void Function(Pointer<Void> ptr)

RacFreeNative = Void Function(Pointer<Void> ptr)

void rac_free(void* ptr)

RacGetMemoryInfoCallbackNative = Int32 Function(Pointer<Void> outInfo, Pointer<Void> userData)

Get memory info callback: rac_result_t (get_memory_info)(rac_memory_info_t out_info, void* user_data)

RacHandle = Pointer<Void>

============================================================================= RunAnywhere Commons FFI Type Definitions

RacHttpCompleteCallbackNative = Void Function(Int32 result, Pointer<Utf8> downloadedPath, Pointer<Void> callbackUserData)

HTTP complete callback: void (complete)(rac_result_t result, const char downloaded_path, void* callback_user_data)

RacHttpProgressCallbackNative = Void Function(Int64 bytesDownloaded, Int64 totalBytes, Pointer<Void> callbackUserData)

HTTP progress callback: void (progress)(int64_t bytes_downloaded, int64_t total_bytes, void callback_user_data)

RacInitDart = int Function(Pointer<Void> config)

RacInitNative = Int32 Function(Pointer<Void> config)

rac_result_t rac_init(const rac_config_t* config)

RacIsInitializedDart = int Function()

RacIsInitializedNative = Int32 Function()

rac_bool_t rac_is_initialized(void)

RacLlmComponentCancelDart = int Function(RacHandle handle)

RacLlmComponentCancelNative = Int32 Function(RacHandle handle)

rac_result_t rac_llm_component_cancel(rac_handle_t handle)

RacLlmComponentCleanupDart = int Function(RacHandle handle)

RacLlmComponentCleanupNative = Int32 Function(RacHandle handle)

rac_result_t rac_llm_component_cleanup(rac_handle_t handle)

RacLlmComponentCompleteCallbackNative = Void Function(Pointer<Void> result, Pointer<Void> userData)

LLM streaming complete callback signature

RacLlmComponentCreateDart = int Function(Pointer<RacHandle> outHandle)

RacLlmComponentCreateNative = Int32 Function(Pointer<RacHandle> outHandle)

rac_result_t rac_llm_component_create(rac_handle_t* out_handle)

RacLlmComponentDestroyDart = void Function(RacHandle handle)

RacLlmComponentDestroyNative = Void Function(RacHandle handle)

void rac_llm_component_destroy(rac_handle_t handle)

RacLlmComponentErrorCallbackNative = Void Function(Int32 errorCode, Pointer<Utf8> errorMessage, Pointer<Void> userData)

LLM streaming error callback signature

RacLlmComponentGenerateDart = int Function(RacHandle handle, Pointer<Utf8> prompt, Pointer<Void> options, Pointer<Void> outResult)

RacLlmComponentGenerateNative = Int32 Function(RacHandle handle, Pointer<Utf8> prompt, Pointer<Void> options, Pointer<Void> outResult)

rac_result_t rac_llm_component_generate(rac_handle_t handle, const char* prompt, const rac_llm_options_t* options, rac_llm_result_t* out_result)

RacLlmComponentGenerateStreamDart = int Function(RacHandle handle, Pointer<Utf8> prompt, Pointer<Void> options, Pointer<NativeFunction<RacLlmComponentTokenCallbackNative>> tokenCallback, Pointer<NativeFunction<RacLlmComponentCompleteCallbackNative>> completeCallback, Pointer<NativeFunction<RacLlmComponentErrorCallbackNative>> errorCallback, Pointer<Void> userData)

RacLlmComponentGenerateStreamNative = Int32 Function(RacHandle handle, Pointer<Utf8> prompt, Pointer<Void> options, Pointer<NativeFunction<RacLlmComponentTokenCallbackNative>> tokenCallback, Pointer<NativeFunction<RacLlmComponentCompleteCallbackNative>> completeCallback, Pointer<NativeFunction<RacLlmComponentErrorCallbackNative>> errorCallback, Pointer<Void> userData)

rac_result_t rac_llm_component_generate_stream(...)

RacLlmComponentGetModelIdDart = Pointer<Utf8> Function(RacHandle handle)

RacLlmComponentGetModelIdNative = Pointer<Utf8> Function(RacHandle handle)

const char* rac_llm_component_get_model_id(rac_handle_t handle)

RacLlmComponentIsLoadedDart = int Function(RacHandle handle)

RacLlmComponentIsLoadedNative = Int32 Function(RacHandle handle)

rac_bool_t rac_llm_component_is_loaded(rac_handle_t handle)

RacLlmComponentLoadModelDart = int Function(RacHandle handle, Pointer<Utf8> modelPath, Pointer<Utf8> modelId, Pointer<Utf8> modelName)

RacLlmComponentLoadModelNative = Int32 Function(RacHandle handle, Pointer<Utf8> modelPath, Pointer<Utf8> modelId, Pointer<Utf8> modelName)

rac_result_t rac_llm_component_load_model(rac_handle_t handle, const char* model_path, const char* model_id, const char* model_name)

RacLlmComponentTokenCallbackNative = Int32 Function(Pointer<Utf8> token, Pointer<Void> userData)

LLM streaming token callback signature rac_bool_t (rac_llm_component_token_callback_fn)(const char token, void* user_data)

RacLlmComponentUnloadDart = int Function(RacHandle handle)

RacLlmComponentUnloadNative = Int32 Function(RacHandle handle)

rac_result_t rac_llm_component_unload(rac_handle_t handle)

RacLlmStreamCallbackNative = RacLlmComponentTokenCallbackNative

RacLogCallbackNative = Void Function(Int32 level, Pointer<Utf8> category, Pointer<Utf8> message, Pointer<Void> userData)

Log callback: void (log)(rac_log_level_t level, const char category, const char* message, void* user_data)

RacModuleListDart = int Function(Pointer<Pointer<Void>> outModules, Pointer<IntPtr> outCount)

RacModuleListNative = Int32 Function(Pointer<Pointer<Void>> outModules, Pointer<IntPtr> outCount)

rac_result_t rac_module_list(const rac_module_info_t** out_modules, size_t* out_count)

RacModuleRegisterDart = int Function(Pointer<Void> info)

RacModuleRegisterNative = Int32 Function(Pointer<Void> info)

rac_result_t rac_module_register(const rac_module_info_t* info)

RacModuleUnregisterDart = int Function(Pointer<Utf8> moduleId)

RacModuleUnregisterNative = Int32 Function(Pointer<Utf8> moduleId)

rac_result_t rac_module_unregister(const char* module_id)

RacNowMsCallbackNative = Int64 Function(Pointer<Void> userData)

Now ms callback: int64_t (now_ms)(void user_data)

RacPlatformAdapter = RacPlatformAdapterStruct

Type alias for platform adapter struct

RacResult = Int32

Result type for all RAC functions (rac_result_t) 0 = success, negative = error

RacSecureDeleteCallbackNative = Int32 Function(Pointer<Utf8> key, Pointer<Void> userData)

Secure delete callback: rac_result_t (secure_delete)(const char key, void* user_data)

RacSecureGetCallbackNative = Int32 Function(Pointer<Utf8> key, Pointer<Pointer<Utf8>> outValue, Pointer<Void> userData)

Secure get callback: rac_result_t (secure_get)(const char key, char** out_value, void* user_data)

RacSecureSetCallbackNative = Int32 Function(Pointer<Utf8> key, Pointer<Utf8> value, Pointer<Void> userData)

Secure set callback: rac_result_t (secure_set)(const char key, const char* value, void* user_data)

RacServiceCreateDart = int Function(int capability, Pointer<Void> request, Pointer<RacHandle> outHandle)

RacServiceCreateNative = Int32 Function(Int32 capability, Pointer<Void> request, Pointer<RacHandle> outHandle)

rac_result_t rac_service_create(rac_capability_t capability, const rac_service_request_t* request, rac_handle_t* out_handle)

RacServiceRegisterProviderDart = int Function(Pointer<Void> provider)

RacServiceRegisterProviderNative = Int32 Function(Pointer<Void> provider)

rac_result_t rac_service_register_provider(const rac_service_provider_t* provider)

RacShutdownDart = void Function()

RacShutdownNative = Void Function()

void rac_shutdown(void)

RacStrdupDart = Pointer<Utf8> Function(Pointer<Utf8> str)

RacStrdupNative = Pointer<Utf8> Function(Pointer<Utf8> str)

char* rac_strdup(const char* str)

RacSttOnnxCreateDart = int Function(Pointer<Utf8> modelPath, Pointer<Void> config, Pointer<RacHandle> outHandle)

RacSttOnnxCreateNative = Int32 Function(Pointer<Utf8> modelPath, Pointer<Void> config, Pointer<RacHandle> outHandle)

rac_result_t rac_stt_onnx_create(const char* model_path, const rac_stt_onnx_config_t* config, rac_handle_t* out_handle)

RacSttOnnxCreateStreamDart = int Function(RacHandle handle, Pointer<RacHandle> outStream)

RacSttOnnxCreateStreamNative = Int32 Function(RacHandle handle, Pointer<RacHandle> outStream)

rac_result_t rac_stt_onnx_create_stream(rac_handle_t handle, rac_handle_t* out_stream)

RacSttOnnxDecodeStreamDart = int Function(RacHandle handle, RacHandle stream, Pointer<Pointer<Utf8>> outText)

RacSttOnnxDecodeStreamNative = Int32 Function(RacHandle handle, RacHandle stream, Pointer<Pointer<Utf8>> outText)

rac_result_t rac_stt_onnx_decode_stream(rac_handle_t handle, rac_handle_t stream, char** out_text)

RacSttOnnxDestroyDart = void Function(RacHandle handle)

RacSttOnnxDestroyNative = Void Function(RacHandle handle)

void rac_stt_onnx_destroy(rac_handle_t handle)

RacSttOnnxDestroyStreamDart = void Function(RacHandle handle, RacHandle stream)

RacSttOnnxDestroyStreamNative = Void Function(RacHandle handle, RacHandle stream)

void rac_stt_onnx_destroy_stream(rac_handle_t handle, rac_handle_t stream)

RacSttOnnxFeedAudioDart = int Function(RacHandle handle, RacHandle stream, Pointer<Float> audioSamples, int numSamples)

RacSttOnnxFeedAudioNative = Int32 Function(RacHandle handle, RacHandle stream, Pointer<Float> audioSamples, IntPtr numSamples)

rac_result_t rac_stt_onnx_feed_audio(rac_handle_t handle, rac_handle_t stream, const float* audio_samples, size_t num_samples)

RacSttOnnxInputFinishedDart = void Function(RacHandle handle, RacHandle stream)

RacSttOnnxInputFinishedNative = Void Function(RacHandle handle, RacHandle stream)

void rac_stt_onnx_input_finished(rac_handle_t handle, rac_handle_t stream)

RacSttOnnxIsEndpointDart = int Function(RacHandle handle, RacHandle stream)

RacSttOnnxIsEndpointNative = Int32 Function(RacHandle handle, RacHandle stream)

rac_bool_t rac_stt_onnx_is_endpoint(rac_handle_t handle, rac_handle_t stream)

RacSttOnnxStreamIsReadyDart = int Function(RacHandle handle, RacHandle stream)

RacSttOnnxStreamIsReadyNative = Int32 Function(RacHandle handle, RacHandle stream)

rac_bool_t rac_stt_onnx_stream_is_ready(rac_handle_t handle, rac_handle_t stream)

RacSttOnnxSupportsStreamingDart = int Function(RacHandle handle)

RacSttOnnxSupportsStreamingNative = Int32 Function(RacHandle handle)

rac_bool_t rac_stt_onnx_supports_streaming(rac_handle_t handle)

RacSttOnnxTranscribeDart = int Function(RacHandle handle, Pointer<Float> audioSamples, int numSamples, Pointer<Void> options, Pointer<Void> outResult)

RacSttOnnxTranscribeNative = Int32 Function(RacHandle handle, Pointer<Float> audioSamples, IntPtr numSamples, Pointer<Void> options, Pointer<Void> outResult)

rac_result_t rac_stt_onnx_transcribe(rac_handle_t handle, const float* audio_samples, size_t num_samples, const rac_stt_options_t* options, rac_stt_result_t* out_result)

RacTrackErrorCallbackNative = Void Function(Pointer<Utf8> errorJson, Pointer<Void> userData)

Track error callback: void (track_error)(const char error_json, void* user_data)

RacTtsOnnxCreateDart = int Function(Pointer<Utf8> modelPath, Pointer<Void> config, Pointer<RacHandle> outHandle)

RacTtsOnnxCreateNative = Int32 Function(Pointer<Utf8> modelPath, Pointer<Void> config, Pointer<RacHandle> outHandle)

rac_result_t rac_tts_onnx_create(const char* model_path, const rac_tts_onnx_config_t* config, rac_handle_t* out_handle)

RacTtsOnnxDestroyDart = void Function(RacHandle handle)

RacTtsOnnxDestroyNative = Void Function(RacHandle handle)

void rac_tts_onnx_destroy(rac_handle_t handle)

RacTtsOnnxGetVoicesDart = int Function(RacHandle handle, Pointer<Pointer<Pointer<Utf8>>> outVoices, Pointer<IntPtr> outCount)

RacTtsOnnxGetVoicesNative = Int32 Function(RacHandle handle, Pointer<Pointer<Pointer<Utf8>>> outVoices, Pointer<IntPtr> outCount)

rac_result_t rac_tts_onnx_get_voices(rac_handle_t handle, char*** out_voices, size_t* out_count)

RacTtsOnnxStopDart = void Function(RacHandle handle)

RacTtsOnnxStopNative = Void Function(RacHandle handle)

void rac_tts_onnx_stop(rac_handle_t handle)

RacTtsOnnxSynthesizeDart = int Function(RacHandle handle, Pointer<Utf8> text, Pointer<Void> options, Pointer<Void> outResult)

RacTtsOnnxSynthesizeNative = Int32 Function(RacHandle handle, Pointer<Utf8> text, Pointer<Void> options, Pointer<Void> outResult)

rac_result_t rac_tts_onnx_synthesize(rac_handle_t handle, const char* text, const rac_tts_options_t* options, rac_tts_result_t* out_result)

RacVadOnnxCreateDart = int Function(Pointer<Utf8> modelPath, Pointer<Void> config, Pointer<RacHandle> outHandle)

RacVadOnnxCreateNative = Int32 Function(Pointer<Utf8> modelPath, Pointer<Void> config, Pointer<RacHandle> outHandle)

rac_result_t rac_vad_onnx_create(const char* model_path, const rac_vad_onnx_config_t* config, rac_handle_t* out_handle)

RacVadOnnxDestroyDart = void Function(RacHandle handle)

RacVadOnnxDestroyNative = Void Function(RacHandle handle)

void rac_vad_onnx_destroy(rac_handle_t handle)

RacVadOnnxProcessDart = int Function(RacHandle handle, Pointer<Float> samples, int numSamples, Pointer<Void> outResult)

RacVadOnnxProcessNative = Int32 Function(RacHandle handle, Pointer<Float> samples, IntPtr numSamples, Pointer<Void> outResult)

rac_result_t rac_vad_onnx_process(rac_handle_t handle, const float* samples, size_t num_samples, rac_vad_result_t* out_result)

RaResultCode = RacResultCode

Alias for backward compatibility

RaStreamHandle = RacHandle