diff --git a/libraries/API_PARITY.md b/libraries/API_PARITY.md new file mode 100644 index 0000000..f278f71 --- /dev/null +++ b/libraries/API_PARITY.md @@ -0,0 +1,79 @@ +# API Parity Reference + +Cross-platform availability matrix for Locanara wrapper libraries. + +## Core AI Features + +| API | expo-ondevice-ai | react-native-ondevice-ai | flutter_ondevice_ai | Notes | +| --- | :---: | :---: | :---: | --- | +| `initialize()` | ✅ | ✅ | ✅ | | +| `getDeviceCapability()` | ✅ | ✅ | ✅ | | +| `summarize(text, options?)` | ✅ | ✅ | ✅ | | +| `classify(text, options?)` | ✅ | ✅ | ✅ | | +| `extract(text, options?)` | ✅ | ✅ | ✅ | | +| `chat(message, options?)` | ✅ | ✅ | ✅ | | +| `chatStream(message, options?)` | ✅ | ✅ | ✅ | Streaming via `onChunk` callback | +| `translate(text, options)` | ✅ | ✅ | ✅ | | +| `rewrite(text, options)` | ✅ | ✅ | ✅ | | +| `proofread(text, options?)` | ✅ | ✅ | ✅ | | + +## Streaming Variants + +Streaming is supported for all text-generation features via callback-based APIs. Each +streaming function accepts an `onChunk` callback that delivers tokens progressively. + +| API | expo-ondevice-ai | react-native-ondevice-ai | flutter_ondevice_ai | Notes | +| --- | :---: | :---: | :---: | --- | +| `summarizeStreaming(text, options?)` | ✅ | ✅ | 🚧 | `onChunk` callback | +| `translateStreaming(text, options)` | ✅ | ✅ | 🚧 | `onChunk` callback | +| `rewriteStreaming(text, options)` | ✅ | ✅ | 🚧 | `onChunk` callback | +| `chatStream(message, options?)` | ✅ | ✅ | ✅ | Already supported | + +## Image Features + +| API | expo-ondevice-ai | react-native-ondevice-ai | flutter_ondevice_ai | Notes | +| --- | :---: | :---: | :---: | --- | +| `describeImage(imageUri, options?)` | ✅ | ✅ | 🚧 | iOS (Foundation Models Vision) + Android (describeImageAndroid) | +| `describeImageStreaming(imageUri, options?)` | 🚧 | 🚧 | 🚧 | Planned | + +## Chrome-Only Features + +These APIs are available exclusively in the **Web SDK** (`@locanara/web`) because they +rely on Chrome's Built-in AI APIs. They are **not available** in Expo, React Native, or +Flutter wrapper libraries. + +| API | Web SDK | Wrappers | Reason | +| --- | :---: | :---: | --- | +| `detectLanguage(text)` | ✅ | ❌ | Chrome Language Detection API only | +| `write(prompt, options?)` | ✅ | ❌ | Chrome Writer API only | +| `writeStreaming(prompt, options?)` | ✅ | ❌ | Chrome Writer API only | + +If you need language detection on mobile, consider using a third-party library like +`react-native-mlkit` or the device's built-in locale detection. + +## Model Management + +| API | expo-ondevice-ai | react-native-ondevice-ai | flutter_ondevice_ai | Notes | +| --- | :---: | :---: | :---: | --- | +| `getAvailableModels()` | ✅ | ✅ | ✅ | iOS only — returns `[]` on Android | +| `getDownloadedModels()` | ✅ | ✅ | ✅ | iOS only — returns `[]` on Android | +| `getLoadedModel()` | ✅ | ✅ | ✅ | | +| `getCurrentEngine()` | ✅ | ✅ | ✅ | | +| `downloadModel(id, onProgress?)` | ✅ | ✅ | ✅ | iOS only | +| `loadModel(id)` | ✅ | ✅ | ✅ | iOS only | +| `deleteModel(id)` | ✅ | ✅ | ✅ | iOS only | + +## Android-Only Features + +| API | expo-ondevice-ai | react-native-ondevice-ai | flutter_ondevice_ai | Notes | +| --- | :---: | :---: | :---: | --- | +| `getPromptApiStatus()` | ✅ | ✅ | ✅ | Android only — Gemini Nano Prompt API status | +| `downloadPromptApiModel(onProgress?)` | ✅ | ✅ | ✅ | Android only — download Gemini Nano | + +## Legend + +| Symbol | Meaning | +| --- | --- | +| ✅ | Available | +| 🚧 | Planned / In Progress | +| ❌ | Not available on this platform | diff --git a/libraries/expo-ondevice-ai/src/index.ts b/libraries/expo-ondevice-ai/src/index.ts index bd3d661..93fa7dd 100644 --- a/libraries/expo-ondevice-ai/src/index.ts +++ b/libraries/expo-ondevice-ai/src/index.ts @@ -4,6 +4,7 @@ import type { DeviceCapability, SummarizeOptions, SummarizeResult, + SummarizeStreamOptions, ClassifyOptions, ClassifyResult, ExtractOptions, @@ -12,16 +13,21 @@ import type { ChatResult, ChatStreamChunk, ChatStreamOptions, + TextStreamChunk, TranslateOptions, TranslateResult, + TranslateStreamOptions, RewriteOptions, RewriteResult, + RewriteStreamOptions, ProofreadOptions, ProofreadResult, InitializeResult, DownloadableModelInfo, ModelDownloadProgress, InferenceEngine, + DescribeImageOptions, + DescribeImageResult, } from './types'; import {ExpoOndeviceAiLog as Log} from './log'; @@ -172,6 +178,140 @@ export async function proofread( return ExpoOndeviceAiModule.proofread(text, options); } +// MARK: - Streaming Variants + +/** + * Summarize text with streaming — tokens delivered progressively via onChunk. + * @param text - The text to summarize + * @param options - Options including onChunk callback + * @returns Promise resolving to final SummarizeResult + */ +export async function summarizeStreaming( + text: string, + options?: SummarizeStreamOptions, +): Promise { + let subscription: EventSubscription | undefined; + + try { + if (options?.onChunk) { + subscription = ( + ExpoOndeviceAiModule as unknown as { + addListener: ( + name: string, + listener: (chunk: TextStreamChunk) => void, + ) => EventSubscription; + } + ).addListener('onSummarizeStreamChunk', (chunk: TextStreamChunk) => { + options.onChunk!(chunk); + }); + } + + const {onChunk: _, ...nativeOptions} = options ?? {}; + const result: SummarizeResult = await ExpoOndeviceAiModule.summarizeStreaming( + text, + Object.keys(nativeOptions).length > 0 ? nativeOptions : undefined, + ); + + await new Promise((resolve) => setTimeout(resolve, 0)); + return result; + } finally { + subscription?.remove(); + } +} + +/** + * Translate text with streaming — tokens delivered progressively via onChunk. + * @param text - The text to translate + * @param options - Options including targetLanguage and onChunk callback + * @returns Promise resolving to final TranslateResult + */ +export async function translateStreaming( + text: string, + options: TranslateStreamOptions, +): Promise { + let subscription: EventSubscription | undefined; + + try { + if (options.onChunk) { + subscription = ( + ExpoOndeviceAiModule as unknown as { + addListener: ( + name: string, + listener: (chunk: TextStreamChunk) => void, + ) => EventSubscription; + } + ).addListener('onTranslateStreamChunk', (chunk: TextStreamChunk) => { + options.onChunk!(chunk); + }); + } + + const {onChunk: _, ...nativeOptions} = options; + const result: TranslateResult = await ExpoOndeviceAiModule.translateStreaming( + text, + nativeOptions, + ); + + await new Promise((resolve) => setTimeout(resolve, 0)); + return result; + } finally { + subscription?.remove(); + } +} + +/** + * Rewrite text with streaming — tokens delivered progressively via onChunk. + * @param text - The text to rewrite + * @param options - Options including outputType and onChunk callback + * @returns Promise resolving to final RewriteResult + */ +export async function rewriteStreaming( + text: string, + options: RewriteStreamOptions, +): Promise { + let subscription: EventSubscription | undefined; + + try { + if (options.onChunk) { + subscription = ( + ExpoOndeviceAiModule as unknown as { + addListener: ( + name: string, + listener: (chunk: TextStreamChunk) => void, + ) => EventSubscription; + } + ).addListener('onRewriteStreamChunk', (chunk: TextStreamChunk) => { + options.onChunk!(chunk); + }); + } + + const {onChunk: _, ...nativeOptions} = options; + const result: RewriteResult = await ExpoOndeviceAiModule.rewriteStreaming( + text, + nativeOptions, + ); + + await new Promise((resolve) => setTimeout(resolve, 0)); + return result; + } finally { + subscription?.remove(); + } +} + +// MARK: - Image Description + +/** + * Describe the contents of an image using on-device AI. + * Supported on iOS (Foundation Models Vision API) and Android. + * @param imageUri - URI or file path to the image + * @param options - Optional prompt and other options + */ +export async function describeImage( + imageUri: string, + options?: DescribeImageOptions, +): Promise { + return ExpoOndeviceAiModule.describeImage(imageUri, options); +} + // MARK: - Model Management /** diff --git a/libraries/expo-ondevice-ai/src/types.ts b/libraries/expo-ondevice-ai/src/types.ts index 400016f..557e9a4 100644 --- a/libraries/expo-ondevice-ai/src/types.ts +++ b/libraries/expo-ondevice-ai/src/types.ts @@ -200,6 +200,62 @@ export interface ChatStreamOptions extends ChatOptions { onChunk?: (chunk: ChatStreamChunk) => void; } +/** + * A single streamed chunk for summarize / translate / rewrite streaming + */ +export interface TextStreamChunk { + /** New text delta in this chunk */ + delta: string; + /** Full accumulated text so far */ + accumulated: string; + /** Whether this is the final chunk */ + isFinal: boolean; +} + +/** + * Options for streaming summarization + */ +export interface SummarizeStreamOptions extends SummarizeOptions { + /** Callback invoked for each streamed token */ + onChunk?: (chunk: TextStreamChunk) => void; +} + +/** + * Options for streaming translation + */ +export interface TranslateStreamOptions extends TranslateOptions { + /** Callback invoked for each streamed token */ + onChunk?: (chunk: TextStreamChunk) => void; +} + +/** + * Options for streaming rewrite + */ +export interface RewriteStreamOptions extends RewriteOptions { + /** Callback invoked for each streamed token */ + onChunk?: (chunk: TextStreamChunk) => void; +} + +// MARK: - Image Description + +/** + * Options for image description + */ +export interface DescribeImageOptions { + /** Optional prompt to guide the description */ + prompt?: string; +} + +/** + * Result of image description + */ +export interface DescribeImageResult { + /** The generated description */ + description: string; + /** Confidence score (0-1) */ + confidence?: number; +} + /** * Options for translation */ diff --git a/libraries/react-native-ondevice-ai/android/src/main/java/com/margelo/nitro/ondeviceai/HybridOndeviceAi.kt b/libraries/react-native-ondevice-ai/android/src/main/java/com/margelo/nitro/ondeviceai/HybridOndeviceAi.kt index 28cf8ef..38854f0 100644 --- a/libraries/react-native-ondevice-ai/android/src/main/java/com/margelo/nitro/ondeviceai/HybridOndeviceAi.kt +++ b/libraries/react-native-ondevice-ai/android/src/main/java/com/margelo/nitro/ondeviceai/HybridOndeviceAi.kt @@ -41,6 +41,9 @@ class HybridOndeviceAi : HybridOndeviceAiSpec() { // Listener storage (thread-safe) private val chatStreamListeners = java.util.concurrent.CopyOnWriteArrayList<(NitroChatStreamChunk) -> Unit>() + private val summarizeStreamListeners = java.util.concurrent.CopyOnWriteArrayList<(NitroTextStreamChunk) -> Unit>() + private val translateStreamListeners = java.util.concurrent.CopyOnWriteArrayList<(NitroTextStreamChunk) -> Unit>() + private val rewriteStreamListeners = java.util.concurrent.CopyOnWriteArrayList<(NitroTextStreamChunk) -> Unit>() private val modelDownloadProgressListeners = java.util.concurrent.CopyOnWriteArrayList<(NitroModelDownloadProgress) -> Unit>() // Simulated model state (matches native example behavior) @@ -201,6 +204,87 @@ class HybridOndeviceAi : HybridOndeviceAiSpec() { } } + // ────────────────────────────────────────────────────────────────── + // Streaming Variants (Summarize / Translate / Rewrite) + // Chains don't expose token-level streaming, so we emit a single + // final chunk after the regular run completes. + // ────────────────────────────────────────────────────────────────── + + override fun summarizeStreaming(text: String, options: Variant_NullType_NitroSummarizeOptions?): Promise { + return Promise.async { + val bulletCount = OndeviceAiHelper.bulletCount(options) + val inputType = OndeviceAiHelper.inputType(options) + val result = SummarizeChain(bulletCount = bulletCount, inputType = inputType).run(text) + val chunk = NitroTextStreamChunk(delta = result.summary, accumulated = result.summary, isFinal = true) + summarizeStreamListeners.forEach { it(chunk) } + NitroSummarizeResult( + summary = result.summary, + originalLength = result.originalLength.toDouble(), + summaryLength = result.summaryLength.toDouble(), + confidence = result.confidence ?: 0.0, + ) + } + } + + override fun addSummarizeStreamListener(listener: (NitroTextStreamChunk) -> Unit) { + summarizeStreamListeners.add(listener) + } + + override fun removeSummarizeStreamListener(listener: (NitroTextStreamChunk) -> Unit) { + summarizeStreamListeners.remove(listener) + } + + override fun translateStreaming(text: String, options: NitroTranslateOptions): Promise { + return Promise.async { + val (source, target) = OndeviceAiHelper.translateOptions(options) + val result = TranslateChain(sourceLanguage = source, targetLanguage = target).run(text) + val chunk = NitroTextStreamChunk(delta = result.translatedText, accumulated = result.translatedText, isFinal = true) + translateStreamListeners.forEach { it(chunk) } + NitroTranslateResult( + translatedText = result.translatedText, + sourceLanguage = result.sourceLanguage, + targetLanguage = result.targetLanguage, + confidence = result.confidence ?: 0.0, + ) + } + } + + override fun addTranslateStreamListener(listener: (NitroTextStreamChunk) -> Unit) { + translateStreamListeners.add(listener) + } + + override fun removeTranslateStreamListener(listener: (NitroTextStreamChunk) -> Unit) { + translateStreamListeners.remove(listener) + } + + override fun rewriteStreaming(text: String, options: NitroRewriteOptions): Promise { + return Promise.async { + val style = OndeviceAiHelper.rewriteStyle(options) + val result = RewriteChain(style = style).run(text) + val chunk = NitroTextStreamChunk(delta = result.rewrittenText, accumulated = result.rewrittenText, isFinal = true) + rewriteStreamListeners.forEach { it(chunk) } + NitroRewriteResult( + rewrittenText = result.rewrittenText, + style = result.style?.name ?: "", + confidence = result.confidence ?: 0.0, + ) + } + } + + override fun addRewriteStreamListener(listener: (NitroTextStreamChunk) -> Unit) { + rewriteStreamListeners.add(listener) + } + + override fun removeRewriteStreamListener(listener: (NitroTextStreamChunk) -> Unit) { + rewriteStreamListeners.remove(listener) + } + + override fun describeImage(imageUri: String, options: Variant_NullType_NitroDescribeImageOptions?): Promise { + return Promise.async { + throw Exception("describeImage is not supported on Android. This feature requires the Web SDK (Chrome Built-in AI).") + } + } + // ────────────────────────────────────────────────────────────────── // Chat Streaming // ────────────────────────────────────────────────────────────────── diff --git a/libraries/react-native-ondevice-ai/ios/HybridOndeviceAi.swift b/libraries/react-native-ondevice-ai/ios/HybridOndeviceAi.swift index 24c078a..3933e4d 100644 --- a/libraries/react-native-ondevice-ai/ios/HybridOndeviceAi.swift +++ b/libraries/react-native-ondevice-ai/ios/HybridOndeviceAi.swift @@ -11,6 +11,9 @@ class HybridOndeviceAi: HybridOndeviceAiSpec { private let listenerQueue = DispatchQueue(label: "com.locanara.ondeviceai.listeners") private var chatStreamListeners: [(NitroChatStreamChunk) -> Void] = [] + private var summarizeStreamListeners: [(NitroTextStreamChunk) -> Void] = [] + private var translateStreamListeners: [(NitroTextStreamChunk) -> Void] = [] + private var rewriteStreamListeners: [(NitroTextStreamChunk) -> Void] = [] private var modelDownloadProgressListeners: [(NitroModelDownloadProgress) -> Void] = [] // MARK: - Initialization @@ -160,6 +163,93 @@ class HybridOndeviceAi: HybridOndeviceAiSpec { } } + // MARK: - Streaming Variants (Summarize / Translate / Rewrite) + // Chains don't expose token-level streaming, so we emit a single + // final chunk after the regular run completes. + + func summarizeStreaming(text: String, options: Variant_NullType_NitroSummarizeOptions?) throws -> Promise { + let opts: NitroSummarizeOptions? = if case .second(let v)? = options { v } else { nil } + return Promise.async { + let bulletCount = OndeviceAiHelper.bulletCount(from: opts) + let inputType = OndeviceAiHelper.inputType(from: opts) + let result = try await SummarizeChain(bulletCount: bulletCount, inputType: inputType).run(text) + let chunk = NitroTextStreamChunk(delta: result.summary, accumulated: result.summary, isFinal: true) + let listeners = self.listenerQueue.sync { self.summarizeStreamListeners } + for listener in listeners { listener(chunk) } + return NitroSummarizeResult( + summary: result.summary, + originalLength: Double(result.originalLength), + summaryLength: Double(result.summaryLength), + confidence: result.confidence ?? 0.0 + ) + } + } + + func addSummarizeStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws { + listenerQueue.sync { summarizeStreamListeners.append(listener) } + } + + func removeSummarizeStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws { + listenerQueue.sync { summarizeStreamListeners.removeAll { $0 as AnyObject === listener as AnyObject } } + } + + func translateStreaming(text: String, options: NitroTranslateOptions) throws -> Promise { + return Promise.async { + let (source, target) = OndeviceAiHelper.translateOptions(from: options) + let result = try await TranslateChain(sourceLanguage: source, targetLanguage: target).run(text) + let chunk = NitroTextStreamChunk(delta: result.translatedText, accumulated: result.translatedText, isFinal: true) + let listeners = self.listenerQueue.sync { self.translateStreamListeners } + for listener in listeners { listener(chunk) } + return NitroTranslateResult( + translatedText: result.translatedText, + sourceLanguage: result.sourceLanguage, + targetLanguage: result.targetLanguage, + confidence: result.confidence ?? 0.0 + ) + } + } + + func addTranslateStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws { + listenerQueue.sync { translateStreamListeners.append(listener) } + } + + func removeTranslateStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws { + listenerQueue.sync { translateStreamListeners.removeAll { $0 as AnyObject === listener as AnyObject } } + } + + func rewriteStreaming(text: String, options: NitroRewriteOptions) throws -> Promise { + return Promise.async { + let style = OndeviceAiHelper.rewriteStyle(from: options) + let result = try await RewriteChain(style: style).run(text) + let chunk = NitroTextStreamChunk(delta: result.rewrittenText, accumulated: result.rewrittenText, isFinal: true) + let listeners = self.listenerQueue.sync { self.rewriteStreamListeners } + for listener in listeners { listener(chunk) } + return NitroRewriteResult( + rewrittenText: result.rewrittenText, + style: result.style?.rawValue ?? "", + confidence: result.confidence ?? 0.0 + ) + } + } + + func addRewriteStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws { + listenerQueue.sync { rewriteStreamListeners.append(listener) } + } + + func removeRewriteStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws { + listenerQueue.sync { rewriteStreamListeners.removeAll { $0 as AnyObject === listener as AnyObject } } + } + + func describeImage(imageUri: String, options: Variant_NullType_NitroDescribeImageOptions?) throws -> Promise { + return Promise.async { + throw NSError( + domain: "OndeviceAi", + code: -1, + userInfo: [NSLocalizedDescriptionKey: "describeImage is not supported on iOS/Android. This feature requires the Web SDK (Chrome Built-in AI)."] + ) + } + } + // MARK: - Chat Streaming func chatStream(message: String, options: Variant_NullType_NitroChatOptions?) throws -> Promise { diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/.gitattributes b/libraries/react-native-ondevice-ai/nitrogen/generated/.gitattributes new file mode 100644 index 0000000..fb7a0d5 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/.gitattributes @@ -0,0 +1 @@ +** linguist-generated=true diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAi+autolinking.cmake b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAi+autolinking.cmake new file mode 100644 index 0000000..3ddf203 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAi+autolinking.cmake @@ -0,0 +1,90 @@ +# +# NitroOndeviceAi+autolinking.cmake +# This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +# https://github.com/mrousavy/nitro +# Copyright © 2026 Marc Rousavy @ Margelo +# + +# This is a CMake file that adds all files generated by Nitrogen +# to the current CMake project. +# +# To use it, add this to your CMakeLists.txt: +# ```cmake +# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroOndeviceAi+autolinking.cmake) +# ``` + +# Define a flag to check if we are building properly +add_definitions(-DBUILDING_NITROONDEVICEAI_WITH_GENERATED_CMAKE_PROJECT) + +# Enable Raw Props parsing in react-native (for Nitro Views) +add_definitions(-DRN_SERIALIZABLE_STATE) + +# Add all headers that were generated by Nitrogen +include_directories( + "../nitrogen/generated/shared/c++" + "../nitrogen/generated/android/c++" + "../nitrogen/generated/android/" +) + +# Add all .cpp sources that were generated by Nitrogen +target_sources( + # CMake project name (Android C++ library name) + NitroOndeviceAi PRIVATE + # Autolinking Setup + ../nitrogen/generated/android/NitroOndeviceAiOnLoad.cpp + # Shared Nitrogen C++ sources + ../nitrogen/generated/shared/c++/HybridOndeviceAiSpec.cpp + # Android-specific Nitrogen C++ sources + ../nitrogen/generated/android/c++/JHybridOndeviceAiSpec.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_NitroSummarizeOptions.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_NitroClassifyOptions.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_Array_String_.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_Double.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_NitroExtractOptions.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_NitroChatOptions.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_String.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_Array_NitroChatMessage_.cpp + ../nitrogen/generated/android/c++/JVariant_NullType_NitroDescribeImageOptions.cpp +) + +# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake +# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake +target_compile_definitions( + NitroOndeviceAi PRIVATE + -DFOLLY_NO_CONFIG=1 + -DFOLLY_HAVE_CLOCK_GETTIME=1 + -DFOLLY_USE_LIBCPP=1 + -DFOLLY_CFG_NO_COROUTINES=1 + -DFOLLY_MOBILE=1 + -DFOLLY_HAVE_RECVMMSG=1 + -DFOLLY_HAVE_PTHREAD=1 + # Once we target android-23 above, we can comment + # the following line. NDK uses GNU style stderror_r() after API 23. + -DFOLLY_HAVE_XSI_STRERROR_R=1 +) + +# Add all libraries required by the generated specs +find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++ +find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule) +find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library + +# Link all libraries together +target_link_libraries( + NitroOndeviceAi + fbjni::fbjni # <-- Facebook C++ JNI helpers + ReactAndroid::jsi # <-- RN: JSI + react-native-nitro-modules::NitroModules # <-- NitroModules Core :) +) + +# Link react-native (different prefab between RN 0.75 and RN 0.76) +if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76) + target_link_libraries( + NitroOndeviceAi + ReactAndroid::reactnative # <-- RN: Native Modules umbrella prefab + ) +else() + target_link_libraries( + NitroOndeviceAi + ReactAndroid::react_nativemodule_core # <-- RN: TurboModules Core + ) +endif() diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAi+autolinking.gradle b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAi+autolinking.gradle new file mode 100644 index 0000000..f0e5004 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAi+autolinking.gradle @@ -0,0 +1,27 @@ +/// +/// NitroOndeviceAi+autolinking.gradle +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/// This is a Gradle file that adds all files generated by Nitrogen +/// to the current Gradle project. +/// +/// To use it, add this to your build.gradle: +/// ```gradle +/// apply from: '../nitrogen/generated/android/NitroOndeviceAi+autolinking.gradle' +/// ``` + +logger.warn("[NitroModules] 🔥 NitroOndeviceAi is boosted by nitro!") + +android { + sourceSets { + main { + java.srcDirs += [ + // Nitrogen files + "${project.projectDir}/../nitrogen/generated/android/kotlin" + ] + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAiOnLoad.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAiOnLoad.cpp new file mode 100644 index 0000000..781c41a --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAiOnLoad.cpp @@ -0,0 +1,50 @@ +/// +/// NitroOndeviceAiOnLoad.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#ifndef BUILDING_NITROONDEVICEAI_WITH_GENERATED_CMAKE_PROJECT +#error NitroOndeviceAiOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this? +#endif + +#include "NitroOndeviceAiOnLoad.hpp" + +#include +#include +#include + +#include "JHybridOndeviceAiSpec.hpp" +#include "JFunc_void_NitroChatStreamChunk.hpp" +#include "JFunc_void_NitroTextStreamChunk.hpp" +#include "JFunc_void_NitroModelDownloadProgress.hpp" +#include + +namespace margelo::nitro::ondeviceai { + +int initialize(JavaVM* vm) { + using namespace margelo::nitro; + using namespace margelo::nitro::ondeviceai; + using namespace facebook; + + return facebook::jni::initialize(vm, [] { + // Register native JNI methods + margelo::nitro::ondeviceai::JHybridOndeviceAiSpec::registerNatives(); + margelo::nitro::ondeviceai::JFunc_void_NitroChatStreamChunk_cxx::registerNatives(); + margelo::nitro::ondeviceai::JFunc_void_NitroTextStreamChunk_cxx::registerNatives(); + margelo::nitro::ondeviceai::JFunc_void_NitroModelDownloadProgress_cxx::registerNatives(); + + // Register Nitro Hybrid Objects + HybridObjectRegistry::registerHybridObjectConstructor( + "OndeviceAi", + []() -> std::shared_ptr { + static DefaultConstructableObject object("com/margelo/nitro/ondeviceai/HybridOndeviceAi"); + auto instance = object.create(); + return instance->cthis()->shared(); + } + ); + }); +} + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAiOnLoad.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAiOnLoad.hpp new file mode 100644 index 0000000..a273c6e --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/NitroOndeviceAiOnLoad.hpp @@ -0,0 +1,25 @@ +/// +/// NitroOndeviceAiOnLoad.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include +#include + +namespace margelo::nitro::ondeviceai { + + /** + * Initializes the native (C++) part of NitroOndeviceAi, and autolinks all Hybrid Objects. + * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`). + * Example: + * ```cpp (cpp-adapter.cpp) + * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) { + * return margelo::nitro::ondeviceai::initialize(vm); + * } + * ``` + */ + int initialize(JavaVM* vm); + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroChatStreamChunk.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroChatStreamChunk.hpp new file mode 100644 index 0000000..f47e281 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroChatStreamChunk.hpp @@ -0,0 +1,78 @@ +/// +/// JFunc_void_NitroChatStreamChunk.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include "NitroChatStreamChunk.hpp" +#include +#include +#include "JNitroChatStreamChunk.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * Represents the Java/Kotlin callback `(chunk: NitroChatStreamChunk) -> Unit`. + * This can be passed around between C++ and Java/Kotlin. + */ + struct JFunc_void_NitroChatStreamChunk: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Func_void_NitroChatStreamChunk;"; + + public: + /** + * Invokes the function this `JFunc_void_NitroChatStreamChunk` instance holds through JNI. + */ + void invoke(const NitroChatStreamChunk& chunk) const { + static const auto method = javaClassStatic()->getMethod /* chunk */)>("invoke"); + method(self(), JNitroChatStreamChunk::fromCpp(chunk)); + } + }; + + /** + * An implementation of Func_void_NitroChatStreamChunk that is backed by a C++ implementation (using `std::function<...>`) + */ + class JFunc_void_NitroChatStreamChunk_cxx final: public jni::HybridClass { + public: + static jni::local_ref fromCpp(const std::function& func) { + return JFunc_void_NitroChatStreamChunk_cxx::newObjectCxxArgs(func); + } + + public: + /** + * Invokes the C++ `std::function<...>` this `JFunc_void_NitroChatStreamChunk_cxx` instance holds. + */ + void invoke_cxx(jni::alias_ref chunk) { + _func(chunk->toCpp()); + } + + public: + [[nodiscard]] + inline const std::function& getFunction() const { + return _func; + } + + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Func_void_NitroChatStreamChunk_cxx;"; + static void registerNatives() { + registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_NitroChatStreamChunk_cxx::invoke_cxx)}); + } + + private: + explicit JFunc_void_NitroChatStreamChunk_cxx(const std::function& func): _func(func) { } + + private: + friend HybridBase; + std::function _func; + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroModelDownloadProgress.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroModelDownloadProgress.hpp new file mode 100644 index 0000000..a2ebbdc --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroModelDownloadProgress.hpp @@ -0,0 +1,80 @@ +/// +/// JFunc_void_NitroModelDownloadProgress.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include "NitroModelDownloadProgress.hpp" +#include +#include +#include "JNitroModelDownloadProgress.hpp" +#include +#include "NitroModelDownloadState.hpp" +#include "JNitroModelDownloadState.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * Represents the Java/Kotlin callback `(progress: NitroModelDownloadProgress) -> Unit`. + * This can be passed around between C++ and Java/Kotlin. + */ + struct JFunc_void_NitroModelDownloadProgress: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Func_void_NitroModelDownloadProgress;"; + + public: + /** + * Invokes the function this `JFunc_void_NitroModelDownloadProgress` instance holds through JNI. + */ + void invoke(const NitroModelDownloadProgress& progress) const { + static const auto method = javaClassStatic()->getMethod /* progress */)>("invoke"); + method(self(), JNitroModelDownloadProgress::fromCpp(progress)); + } + }; + + /** + * An implementation of Func_void_NitroModelDownloadProgress that is backed by a C++ implementation (using `std::function<...>`) + */ + class JFunc_void_NitroModelDownloadProgress_cxx final: public jni::HybridClass { + public: + static jni::local_ref fromCpp(const std::function& func) { + return JFunc_void_NitroModelDownloadProgress_cxx::newObjectCxxArgs(func); + } + + public: + /** + * Invokes the C++ `std::function<...>` this `JFunc_void_NitroModelDownloadProgress_cxx` instance holds. + */ + void invoke_cxx(jni::alias_ref progress) { + _func(progress->toCpp()); + } + + public: + [[nodiscard]] + inline const std::function& getFunction() const { + return _func; + } + + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Func_void_NitroModelDownloadProgress_cxx;"; + static void registerNatives() { + registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_NitroModelDownloadProgress_cxx::invoke_cxx)}); + } + + private: + explicit JFunc_void_NitroModelDownloadProgress_cxx(const std::function& func): _func(func) { } + + private: + friend HybridBase; + std::function _func; + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroTextStreamChunk.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroTextStreamChunk.hpp new file mode 100644 index 0000000..11d9437 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JFunc_void_NitroTextStreamChunk.hpp @@ -0,0 +1,78 @@ +/// +/// JFunc_void_NitroTextStreamChunk.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include "NitroTextStreamChunk.hpp" +#include +#include +#include "JNitroTextStreamChunk.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * Represents the Java/Kotlin callback `(chunk: NitroTextStreamChunk) -> Unit`. + * This can be passed around between C++ and Java/Kotlin. + */ + struct JFunc_void_NitroTextStreamChunk: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Func_void_NitroTextStreamChunk;"; + + public: + /** + * Invokes the function this `JFunc_void_NitroTextStreamChunk` instance holds through JNI. + */ + void invoke(const NitroTextStreamChunk& chunk) const { + static const auto method = javaClassStatic()->getMethod /* chunk */)>("invoke"); + method(self(), JNitroTextStreamChunk::fromCpp(chunk)); + } + }; + + /** + * An implementation of Func_void_NitroTextStreamChunk that is backed by a C++ implementation (using `std::function<...>`) + */ + class JFunc_void_NitroTextStreamChunk_cxx final: public jni::HybridClass { + public: + static jni::local_ref fromCpp(const std::function& func) { + return JFunc_void_NitroTextStreamChunk_cxx::newObjectCxxArgs(func); + } + + public: + /** + * Invokes the C++ `std::function<...>` this `JFunc_void_NitroTextStreamChunk_cxx` instance holds. + */ + void invoke_cxx(jni::alias_ref chunk) { + _func(chunk->toCpp()); + } + + public: + [[nodiscard]] + inline const std::function& getFunction() const { + return _func; + } + + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Func_void_NitroTextStreamChunk_cxx;"; + static void registerNatives() { + registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_NitroTextStreamChunk_cxx::invoke_cxx)}); + } + + private: + explicit JFunc_void_NitroTextStreamChunk_cxx(const std::function& func): _func(func) { } + + private: + friend HybridBase; + std::function _func; + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JHybridOndeviceAiSpec.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JHybridOndeviceAiSpec.cpp new file mode 100644 index 0000000..f9cebe5 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JHybridOndeviceAiSpec.cpp @@ -0,0 +1,615 @@ +/// +/// JHybridOndeviceAiSpec.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JHybridOndeviceAiSpec.hpp" + +// Forward declaration of `NitroDeviceCapability` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDeviceCapability; } +// Forward declaration of `OndeviceAiPlatform` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class OndeviceAiPlatform; } +// Forward declaration of `NitroSummarizeResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeResult; } +// Forward declaration of `NitroClassifyResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyResult; } +// Forward declaration of `NitroClassification` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassification; } +// Forward declaration of `NitroExtractResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractResult; } +// Forward declaration of `NitroExtractEntity` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractEntity; } +// Forward declaration of `NitroChatResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatResult; } +// Forward declaration of `NitroTranslateResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateResult; } +// Forward declaration of `NitroRewriteResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteResult; } +// Forward declaration of `NitroProofreadResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadResult; } +// Forward declaration of `NitroProofreadCorrection` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadCorrection; } +// Forward declaration of `NitroDescribeImageResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageResult; } +// Forward declaration of `NitroModelInfo` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelInfo; } +// Forward declaration of `NitroInferenceEngine` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroInferenceEngine; } +// Forward declaration of `NitroSummarizeOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeOptions; } +// Forward declaration of `NitroSummarizeInputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeInputType; } +// Forward declaration of `NitroSummarizeOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeOutputType; } +// Forward declaration of `NitroClassifyOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyOptions; } +// Forward declaration of `NitroExtractOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractOptions; } +// Forward declaration of `NitroChatOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatOptions; } +// Forward declaration of `NitroChatMessage` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatMessage; } +// Forward declaration of `NitroChatMessageRole` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroChatMessageRole; } +// Forward declaration of `NitroTranslateOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateOptions; } +// Forward declaration of `NitroRewriteOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteOptions; } +// Forward declaration of `NitroRewriteOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroRewriteOutputType; } +// Forward declaration of `NitroChatStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatStreamChunk; } +// Forward declaration of `NitroTextStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTextStreamChunk; } +// Forward declaration of `NitroDescribeImageOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageOptions; } +// Forward declaration of `NitroModelDownloadProgress` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelDownloadProgress; } +// Forward declaration of `NitroModelDownloadState` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroModelDownloadState; } + +#include +#include +#include "NitroDeviceCapability.hpp" +#include "JNitroDeviceCapability.hpp" +#include "OndeviceAiPlatform.hpp" +#include "JOndeviceAiPlatform.hpp" +#include "NitroSummarizeResult.hpp" +#include "JNitroSummarizeResult.hpp" +#include +#include "NitroClassifyResult.hpp" +#include "JNitroClassifyResult.hpp" +#include "NitroClassification.hpp" +#include +#include "JNitroClassification.hpp" +#include "NitroExtractResult.hpp" +#include "JNitroExtractResult.hpp" +#include "NitroExtractEntity.hpp" +#include "JNitroExtractEntity.hpp" +#include "NitroChatResult.hpp" +#include "JNitroChatResult.hpp" +#include "NitroTranslateResult.hpp" +#include "JNitroTranslateResult.hpp" +#include "NitroRewriteResult.hpp" +#include "JNitroRewriteResult.hpp" +#include "NitroProofreadResult.hpp" +#include "JNitroProofreadResult.hpp" +#include "NitroProofreadCorrection.hpp" +#include "JNitroProofreadCorrection.hpp" +#include "NitroDescribeImageResult.hpp" +#include "JNitroDescribeImageResult.hpp" +#include "NitroModelInfo.hpp" +#include "JNitroModelInfo.hpp" +#include "NitroInferenceEngine.hpp" +#include "JNitroInferenceEngine.hpp" +#include +#include "NitroSummarizeOptions.hpp" +#include +#include +#include "JVariant_NullType_NitroSummarizeOptions.hpp" +#include +#include "JNitroSummarizeOptions.hpp" +#include "NitroSummarizeInputType.hpp" +#include "JNitroSummarizeInputType.hpp" +#include "NitroSummarizeOutputType.hpp" +#include "JNitroSummarizeOutputType.hpp" +#include "NitroClassifyOptions.hpp" +#include "JVariant_NullType_NitroClassifyOptions.hpp" +#include "JNitroClassifyOptions.hpp" +#include "JVariant_NullType_Array_String_.hpp" +#include "JVariant_NullType_Double.hpp" +#include "NitroExtractOptions.hpp" +#include "JVariant_NullType_NitroExtractOptions.hpp" +#include "JNitroExtractOptions.hpp" +#include "NitroChatOptions.hpp" +#include "JVariant_NullType_NitroChatOptions.hpp" +#include "JNitroChatOptions.hpp" +#include "JVariant_NullType_String.hpp" +#include "NitroChatMessage.hpp" +#include "JVariant_NullType_Array_NitroChatMessage_.hpp" +#include "JNitroChatMessage.hpp" +#include "NitroChatMessageRole.hpp" +#include "JNitroChatMessageRole.hpp" +#include "NitroTranslateOptions.hpp" +#include "JNitroTranslateOptions.hpp" +#include "NitroRewriteOptions.hpp" +#include "JNitroRewriteOptions.hpp" +#include "NitroRewriteOutputType.hpp" +#include "JNitroRewriteOutputType.hpp" +#include "NitroChatStreamChunk.hpp" +#include +#include "JFunc_void_NitroChatStreamChunk.hpp" +#include +#include "JNitroChatStreamChunk.hpp" +#include "NitroTextStreamChunk.hpp" +#include "JFunc_void_NitroTextStreamChunk.hpp" +#include "JNitroTextStreamChunk.hpp" +#include "NitroDescribeImageOptions.hpp" +#include "JVariant_NullType_NitroDescribeImageOptions.hpp" +#include "JNitroDescribeImageOptions.hpp" +#include "NitroModelDownloadProgress.hpp" +#include "JFunc_void_NitroModelDownloadProgress.hpp" +#include "JNitroModelDownloadProgress.hpp" +#include "NitroModelDownloadState.hpp" +#include "JNitroModelDownloadState.hpp" + +namespace margelo::nitro::ondeviceai { + + jni::local_ref JHybridOndeviceAiSpec::initHybrid(jni::alias_ref jThis) { + return makeCxxInstance(jThis); + } + + void JHybridOndeviceAiSpec::registerNatives() { + registerHybrid({ + makeNativeMethod("initHybrid", JHybridOndeviceAiSpec::initHybrid), + }); + } + + size_t JHybridOndeviceAiSpec::getExternalMemorySize() noexcept { + static const auto method = javaClassStatic()->getMethod("getMemorySize"); + return method(_javaPart); + } + + void JHybridOndeviceAiSpec::dispose() noexcept { + static const auto method = javaClassStatic()->getMethod("dispose"); + method(_javaPart); + } + + std::string JHybridOndeviceAiSpec::toString() { + static const auto method = javaClassStatic()->getMethod("toString"); + auto javaString = method(_javaPart); + return javaString->toStdString(); + } + + // Properties + + + // Methods + std::shared_ptr> JHybridOndeviceAiSpec::initialize() { + static const auto method = javaClassStatic()->getMethod()>("initialize"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(static_cast(__result->value())); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::getDeviceCapability() { + static const auto method = javaClassStatic()->getMethod()>("getDeviceCapability"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::summarize(const std::string& text, const std::optional>& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("summarize"); + auto __result = method(_javaPart, jni::make_jstring(text), options.has_value() ? JVariant_NullType_NitroSummarizeOptions::fromCpp(options.value()) : nullptr); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::classify(const std::string& text, const std::optional>& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("classify"); + auto __result = method(_javaPart, jni::make_jstring(text), options.has_value() ? JVariant_NullType_NitroClassifyOptions::fromCpp(options.value()) : nullptr); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::extract(const std::string& text, const std::optional>& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("extract"); + auto __result = method(_javaPart, jni::make_jstring(text), options.has_value() ? JVariant_NullType_NitroExtractOptions::fromCpp(options.value()) : nullptr); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::chat(const std::string& message, const std::optional>& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* message */, jni::alias_ref /* options */)>("chat"); + auto __result = method(_javaPart, jni::make_jstring(message), options.has_value() ? JVariant_NullType_NitroChatOptions::fromCpp(options.value()) : nullptr); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::translate(const std::string& text, const NitroTranslateOptions& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("translate"); + auto __result = method(_javaPart, jni::make_jstring(text), JNitroTranslateOptions::fromCpp(options)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::rewrite(const std::string& text, const NitroRewriteOptions& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("rewrite"); + auto __result = method(_javaPart, jni::make_jstring(text), JNitroRewriteOptions::fromCpp(options)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::proofread(const std::string& text) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */)>("proofread"); + auto __result = method(_javaPart, jni::make_jstring(text)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::chatStream(const std::string& message, const std::optional>& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* message */, jni::alias_ref /* options */)>("chatStream"); + auto __result = method(_javaPart, jni::make_jstring(message), options.has_value() ? JVariant_NullType_NitroChatOptions::fromCpp(options.value()) : nullptr); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + void JHybridOndeviceAiSpec::addChatStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("addChatStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroChatStreamChunk_cxx::fromCpp(listener)); + } + void JHybridOndeviceAiSpec::removeChatStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("removeChatStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroChatStreamChunk_cxx::fromCpp(listener)); + } + std::shared_ptr> JHybridOndeviceAiSpec::summarizeStreaming(const std::string& text, const std::optional>& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("summarizeStreaming"); + auto __result = method(_javaPart, jni::make_jstring(text), options.has_value() ? JVariant_NullType_NitroSummarizeOptions::fromCpp(options.value()) : nullptr); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + void JHybridOndeviceAiSpec::addSummarizeStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("addSummarizeStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroTextStreamChunk_cxx::fromCpp(listener)); + } + void JHybridOndeviceAiSpec::removeSummarizeStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("removeSummarizeStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroTextStreamChunk_cxx::fromCpp(listener)); + } + std::shared_ptr> JHybridOndeviceAiSpec::translateStreaming(const std::string& text, const NitroTranslateOptions& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("translateStreaming"); + auto __result = method(_javaPart, jni::make_jstring(text), JNitroTranslateOptions::fromCpp(options)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + void JHybridOndeviceAiSpec::addTranslateStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("addTranslateStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroTextStreamChunk_cxx::fromCpp(listener)); + } + void JHybridOndeviceAiSpec::removeTranslateStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("removeTranslateStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroTextStreamChunk_cxx::fromCpp(listener)); + } + std::shared_ptr> JHybridOndeviceAiSpec::rewriteStreaming(const std::string& text, const NitroRewriteOptions& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* text */, jni::alias_ref /* options */)>("rewriteStreaming"); + auto __result = method(_javaPart, jni::make_jstring(text), JNitroRewriteOptions::fromCpp(options)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + void JHybridOndeviceAiSpec::addRewriteStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("addRewriteStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroTextStreamChunk_cxx::fromCpp(listener)); + } + void JHybridOndeviceAiSpec::removeRewriteStreamListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("removeRewriteStreamListener_cxx"); + method(_javaPart, JFunc_void_NitroTextStreamChunk_cxx::fromCpp(listener)); + } + std::shared_ptr> JHybridOndeviceAiSpec::describeImage(const std::string& imageUri, const std::optional>& options) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* imageUri */, jni::alias_ref /* options */)>("describeImage"); + auto __result = method(_javaPart, jni::make_jstring(imageUri), options.has_value() ? JVariant_NullType_NitroDescribeImageOptions::fromCpp(options.value()) : nullptr); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr>> JHybridOndeviceAiSpec::getAvailableModels() { + static const auto method = javaClassStatic()->getMethod()>("getAvailableModels"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise>::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast>(__boxedResult); + __promise->resolve([&]() { + size_t __size = __result->size(); + std::vector __vector; + __vector.reserve(__size); + for (size_t __i = 0; __i < __size; __i++) { + auto __element = __result->getElement(__i); + __vector.push_back(__element->toCpp()); + } + return __vector; + }()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr>> JHybridOndeviceAiSpec::getDownloadedModels() { + static const auto method = javaClassStatic()->getMethod()>("getDownloadedModels"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise>::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast>(__boxedResult); + __promise->resolve([&]() { + size_t __size = __result->size(); + std::vector __vector; + __vector.reserve(__size); + for (size_t __i = 0; __i < __size; __i++) { + auto __element = __result->getElement(__i); + __vector.push_back(__element->toStdString()); + } + return __vector; + }()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::getLoadedModel() { + static const auto method = javaClassStatic()->getMethod()>("getLoadedModel"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toStdString()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::getCurrentEngine() { + static const auto method = javaClassStatic()->getMethod()>("getCurrentEngine"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toCpp()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::downloadModel(const std::string& modelId) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* modelId */)>("downloadModel"); + auto __result = method(_javaPart, jni::make_jstring(modelId)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(static_cast(__result->value())); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + void JHybridOndeviceAiSpec::addModelDownloadProgressListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("addModelDownloadProgressListener_cxx"); + method(_javaPart, JFunc_void_NitroModelDownloadProgress_cxx::fromCpp(listener)); + } + void JHybridOndeviceAiSpec::removeModelDownloadProgressListener(const std::function& listener) { + static const auto method = javaClassStatic()->getMethod /* listener */)>("removeModelDownloadProgressListener_cxx"); + method(_javaPart, JFunc_void_NitroModelDownloadProgress_cxx::fromCpp(listener)); + } + std::shared_ptr> JHybridOndeviceAiSpec::loadModel(const std::string& modelId) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* modelId */)>("loadModel"); + auto __result = method(_javaPart, jni::make_jstring(modelId)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& /* unit */) { + __promise->resolve(); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::deleteModel(const std::string& modelId) { + static const auto method = javaClassStatic()->getMethod(jni::alias_ref /* modelId */)>("deleteModel"); + auto __result = method(_javaPart, jni::make_jstring(modelId)); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& /* unit */) { + __promise->resolve(); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::getPromptApiStatus() { + static const auto method = javaClassStatic()->getMethod()>("getPromptApiStatus"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(__result->toStdString()); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + std::shared_ptr> JHybridOndeviceAiSpec::downloadPromptApiModel() { + static const auto method = javaClassStatic()->getMethod()>("downloadPromptApiModel"); + auto __result = method(_javaPart); + return [&]() { + auto __promise = Promise::create(); + __result->cthis()->addOnResolvedListener([=](const jni::alias_ref& __boxedResult) { + auto __result = jni::static_ref_cast(__boxedResult); + __promise->resolve(static_cast(__result->value())); + }); + __result->cthis()->addOnRejectedListener([=](const jni::alias_ref& __throwable) { + jni::JniException __jniError(__throwable); + __promise->reject(std::make_exception_ptr(__jniError)); + }); + return __promise; + }(); + } + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JHybridOndeviceAiSpec.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JHybridOndeviceAiSpec.hpp new file mode 100644 index 0000000..da1f26c --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JHybridOndeviceAiSpec.hpp @@ -0,0 +1,97 @@ +/// +/// HybridOndeviceAiSpec.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include +#include "HybridOndeviceAiSpec.hpp" + + + + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + class JHybridOndeviceAiSpec: public jni::HybridClass, + public virtual HybridOndeviceAiSpec { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/HybridOndeviceAiSpec;"; + static jni::local_ref initHybrid(jni::alias_ref jThis); + static void registerNatives(); + + protected: + // C++ constructor (called from Java via `initHybrid()`) + explicit JHybridOndeviceAiSpec(jni::alias_ref jThis) : + HybridObject(HybridOndeviceAiSpec::TAG), + HybridBase(jThis), + _javaPart(jni::make_global(jThis)) {} + + public: + ~JHybridOndeviceAiSpec() override { + // Hermes GC can destroy JS objects on a non-JNI Thread. + jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); }); + } + + public: + size_t getExternalMemorySize() noexcept override; + void dispose() noexcept override; + std::string toString() override; + + public: + inline const jni::global_ref& getJavaPart() const noexcept { + return _javaPart; + } + + public: + // Properties + + + public: + // Methods + std::shared_ptr> initialize() override; + std::shared_ptr> getDeviceCapability() override; + std::shared_ptr> summarize(const std::string& text, const std::optional>& options) override; + std::shared_ptr> classify(const std::string& text, const std::optional>& options) override; + std::shared_ptr> extract(const std::string& text, const std::optional>& options) override; + std::shared_ptr> chat(const std::string& message, const std::optional>& options) override; + std::shared_ptr> translate(const std::string& text, const NitroTranslateOptions& options) override; + std::shared_ptr> rewrite(const std::string& text, const NitroRewriteOptions& options) override; + std::shared_ptr> proofread(const std::string& text) override; + std::shared_ptr> chatStream(const std::string& message, const std::optional>& options) override; + void addChatStreamListener(const std::function& listener) override; + void removeChatStreamListener(const std::function& listener) override; + std::shared_ptr> summarizeStreaming(const std::string& text, const std::optional>& options) override; + void addSummarizeStreamListener(const std::function& listener) override; + void removeSummarizeStreamListener(const std::function& listener) override; + std::shared_ptr> translateStreaming(const std::string& text, const NitroTranslateOptions& options) override; + void addTranslateStreamListener(const std::function& listener) override; + void removeTranslateStreamListener(const std::function& listener) override; + std::shared_ptr> rewriteStreaming(const std::string& text, const NitroRewriteOptions& options) override; + void addRewriteStreamListener(const std::function& listener) override; + void removeRewriteStreamListener(const std::function& listener) override; + std::shared_ptr> describeImage(const std::string& imageUri, const std::optional>& options) override; + std::shared_ptr>> getAvailableModels() override; + std::shared_ptr>> getDownloadedModels() override; + std::shared_ptr> getLoadedModel() override; + std::shared_ptr> getCurrentEngine() override; + std::shared_ptr> downloadModel(const std::string& modelId) override; + void addModelDownloadProgressListener(const std::function& listener) override; + void removeModelDownloadProgressListener(const std::function& listener) override; + std::shared_ptr> loadModel(const std::string& modelId) override; + std::shared_ptr> deleteModel(const std::string& modelId) override; + std::shared_ptr> getPromptApiStatus() override; + std::shared_ptr> downloadPromptApiModel() override; + + private: + friend HybridBase; + using HybridBase::HybridBase; + jni::global_ref _javaPart; + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatMessage.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatMessage.hpp new file mode 100644 index 0000000..3518f69 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatMessage.hpp @@ -0,0 +1,63 @@ +/// +/// JNitroChatMessage.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroChatMessage.hpp" + +#include "JNitroChatMessageRole.hpp" +#include "NitroChatMessageRole.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroChatMessage" and the the Kotlin data class "NitroChatMessage". + */ + struct JNitroChatMessage final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroChatMessage;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroChatMessage by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroChatMessage toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldRole = clazz->getField("role"); + jni::local_ref role = this->getFieldValue(fieldRole); + static const auto fieldContent = clazz->getField("content"); + jni::local_ref content = this->getFieldValue(fieldContent); + return NitroChatMessage( + role->toCpp(), + content->toStdString() + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroChatMessage& value) { + using JSignature = JNitroChatMessage(jni::alias_ref, jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + JNitroChatMessageRole::fromCpp(value.role), + jni::make_jstring(value.content) + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatMessageRole.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatMessageRole.hpp new file mode 100644 index 0000000..d783124 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatMessageRole.hpp @@ -0,0 +1,62 @@ +/// +/// JNitroChatMessageRole.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroChatMessageRole.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "NitroChatMessageRole" and the the Kotlin enum "NitroChatMessageRole". + */ + struct JNitroChatMessageRole final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroChatMessageRole;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum NitroChatMessageRole. + */ + [[maybe_unused]] + [[nodiscard]] + NitroChatMessageRole toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(NitroChatMessageRole value) { + static const auto clazz = javaClassStatic(); + static const auto fieldUSER = clazz->getStaticField("USER"); + static const auto fieldASSISTANT = clazz->getStaticField("ASSISTANT"); + static const auto fieldSYSTEM = clazz->getStaticField("SYSTEM"); + + switch (value) { + case NitroChatMessageRole::USER: + return clazz->getStaticFieldValue(fieldUSER); + case NitroChatMessageRole::ASSISTANT: + return clazz->getStaticFieldValue(fieldASSISTANT); + case NitroChatMessageRole::SYSTEM: + return clazz->getStaticFieldValue(fieldSYSTEM); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatOptions.hpp new file mode 100644 index 0000000..2860f3f --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatOptions.hpp @@ -0,0 +1,72 @@ +/// +/// JNitroChatOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroChatOptions.hpp" + +#include "JNitroChatMessage.hpp" +#include "JNitroChatMessageRole.hpp" +#include "JVariant_NullType_Array_NitroChatMessage_.hpp" +#include "JVariant_NullType_String.hpp" +#include "NitroChatMessage.hpp" +#include "NitroChatMessageRole.hpp" +#include +#include +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroChatOptions" and the the Kotlin data class "NitroChatOptions". + */ + struct JNitroChatOptions final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroChatOptions;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroChatOptions by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroChatOptions toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldSystemPrompt = clazz->getField("systemPrompt"); + jni::local_ref systemPrompt = this->getFieldValue(fieldSystemPrompt); + static const auto fieldHistory = clazz->getField("history"); + jni::local_ref history = this->getFieldValue(fieldHistory); + return NitroChatOptions( + systemPrompt != nullptr ? std::make_optional(systemPrompt->toCpp()) : std::nullopt, + history != nullptr ? std::make_optional(history->toCpp()) : std::nullopt + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroChatOptions& value) { + using JSignature = JNitroChatOptions(jni::alias_ref, jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + value.systemPrompt.has_value() ? JVariant_NullType_String::fromCpp(value.systemPrompt.value()) : nullptr, + value.history.has_value() ? JVariant_NullType_Array_NitroChatMessage_::fromCpp(value.history.value()) : nullptr + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatResult.hpp new file mode 100644 index 0000000..cbe9ed2 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatResult.hpp @@ -0,0 +1,65 @@ +/// +/// JNitroChatResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroChatResult.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroChatResult" and the the Kotlin data class "NitroChatResult". + */ + struct JNitroChatResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroChatResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroChatResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroChatResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldMessage = clazz->getField("message"); + jni::local_ref message = this->getFieldValue(fieldMessage); + static const auto fieldConversationId = clazz->getField("conversationId"); + jni::local_ref conversationId = this->getFieldValue(fieldConversationId); + static const auto fieldCanContinue = clazz->getField("canContinue"); + jboolean canContinue = this->getFieldValue(fieldCanContinue); + return NitroChatResult( + message->toStdString(), + conversationId->toStdString(), + static_cast(canContinue) + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroChatResult& value) { + using JSignature = JNitroChatResult(jni::alias_ref, jni::alias_ref, jboolean); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.message), + jni::make_jstring(value.conversationId), + value.canContinue + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatStreamChunk.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatStreamChunk.hpp new file mode 100644 index 0000000..0a1e7fc --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroChatStreamChunk.hpp @@ -0,0 +1,65 @@ +/// +/// JNitroChatStreamChunk.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroChatStreamChunk.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroChatStreamChunk" and the the Kotlin data class "NitroChatStreamChunk". + */ + struct JNitroChatStreamChunk final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroChatStreamChunk;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroChatStreamChunk by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroChatStreamChunk toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldDelta = clazz->getField("delta"); + jni::local_ref delta = this->getFieldValue(fieldDelta); + static const auto fieldAccumulated = clazz->getField("accumulated"); + jni::local_ref accumulated = this->getFieldValue(fieldAccumulated); + static const auto fieldIsFinal = clazz->getField("isFinal"); + jboolean isFinal = this->getFieldValue(fieldIsFinal); + return NitroChatStreamChunk( + delta->toStdString(), + accumulated->toStdString(), + static_cast(isFinal) + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroChatStreamChunk& value) { + using JSignature = JNitroChatStreamChunk(jni::alias_ref, jni::alias_ref, jboolean); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.delta), + jni::make_jstring(value.accumulated), + value.isFinal + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassification.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassification.hpp new file mode 100644 index 0000000..54c8f1e --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassification.hpp @@ -0,0 +1,65 @@ +/// +/// JNitroClassification.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroClassification.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroClassification" and the the Kotlin data class "NitroClassification". + */ + struct JNitroClassification final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroClassification;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroClassification by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroClassification toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldLabel = clazz->getField("label"); + jni::local_ref label = this->getFieldValue(fieldLabel); + static const auto fieldScore = clazz->getField("score"); + double score = this->getFieldValue(fieldScore); + static const auto fieldMetadata = clazz->getField("metadata"); + jni::local_ref metadata = this->getFieldValue(fieldMetadata); + return NitroClassification( + label->toStdString(), + score, + metadata->toStdString() + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroClassification& value) { + using JSignature = JNitroClassification(jni::alias_ref, double, jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.label), + value.score, + jni::make_jstring(value.metadata) + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassifyOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassifyOptions.hpp new file mode 100644 index 0000000..564e59b --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassifyOptions.hpp @@ -0,0 +1,68 @@ +/// +/// JNitroClassifyOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroClassifyOptions.hpp" + +#include "JVariant_NullType_Array_String_.hpp" +#include "JVariant_NullType_Double.hpp" +#include +#include +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroClassifyOptions" and the the Kotlin data class "NitroClassifyOptions". + */ + struct JNitroClassifyOptions final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroClassifyOptions;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroClassifyOptions by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroClassifyOptions toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldCategories = clazz->getField("categories"); + jni::local_ref categories = this->getFieldValue(fieldCategories); + static const auto fieldMaxResults = clazz->getField("maxResults"); + jni::local_ref maxResults = this->getFieldValue(fieldMaxResults); + return NitroClassifyOptions( + categories != nullptr ? std::make_optional(categories->toCpp()) : std::nullopt, + maxResults != nullptr ? std::make_optional(maxResults->toCpp()) : std::nullopt + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroClassifyOptions& value) { + using JSignature = JNitroClassifyOptions(jni::alias_ref, jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + value.categories.has_value() ? JVariant_NullType_Array_String_::fromCpp(value.categories.value()) : nullptr, + value.maxResults.has_value() ? JVariant_NullType_Double::fromCpp(value.maxResults.value()) : nullptr + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassifyResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassifyResult.hpp new file mode 100644 index 0000000..5233080 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroClassifyResult.hpp @@ -0,0 +1,86 @@ +/// +/// JNitroClassifyResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroClassifyResult.hpp" + +#include "JNitroClassification.hpp" +#include "NitroClassification.hpp" +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroClassifyResult" and the the Kotlin data class "NitroClassifyResult". + */ + struct JNitroClassifyResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroClassifyResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroClassifyResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroClassifyResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldClassifications = clazz->getField>("classifications"); + jni::local_ref> classifications = this->getFieldValue(fieldClassifications); + static const auto fieldTopLabel = clazz->getField("topLabel"); + jni::local_ref topLabel = this->getFieldValue(fieldTopLabel); + static const auto fieldTopScore = clazz->getField("topScore"); + double topScore = this->getFieldValue(fieldTopScore); + return NitroClassifyResult( + [&]() { + size_t __size = classifications->size(); + std::vector __vector; + __vector.reserve(__size); + for (size_t __i = 0; __i < __size; __i++) { + auto __element = classifications->getElement(__i); + __vector.push_back(__element->toCpp()); + } + return __vector; + }(), + topLabel->toStdString(), + topScore + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroClassifyResult& value) { + using JSignature = JNitroClassifyResult(jni::alias_ref>, jni::alias_ref, double); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + [&]() { + size_t __size = value.classifications.size(); + jni::local_ref> __array = jni::JArrayClass::newArray(__size); + for (size_t __i = 0; __i < __size; __i++) { + const auto& __element = value.classifications[__i]; + auto __elementJni = JNitroClassification::fromCpp(__element); + __array->setElement(__i, *__elementJni); + } + return __array; + }(), + jni::make_jstring(value.topLabel), + value.topScore + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDescribeImageOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDescribeImageOptions.hpp new file mode 100644 index 0000000..818ed73 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDescribeImageOptions.hpp @@ -0,0 +1,62 @@ +/// +/// JNitroDescribeImageOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroDescribeImageOptions.hpp" + +#include "JVariant_NullType_String.hpp" +#include +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroDescribeImageOptions" and the the Kotlin data class "NitroDescribeImageOptions". + */ + struct JNitroDescribeImageOptions final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroDescribeImageOptions;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroDescribeImageOptions by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroDescribeImageOptions toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldPrompt = clazz->getField("prompt"); + jni::local_ref prompt = this->getFieldValue(fieldPrompt); + return NitroDescribeImageOptions( + prompt != nullptr ? std::make_optional(prompt->toCpp()) : std::nullopt + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroDescribeImageOptions& value) { + using JSignature = JNitroDescribeImageOptions(jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + value.prompt.has_value() ? JVariant_NullType_String::fromCpp(value.prompt.value()) : nullptr + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDescribeImageResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDescribeImageResult.hpp new file mode 100644 index 0000000..1b52659 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDescribeImageResult.hpp @@ -0,0 +1,61 @@ +/// +/// JNitroDescribeImageResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroDescribeImageResult.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroDescribeImageResult" and the the Kotlin data class "NitroDescribeImageResult". + */ + struct JNitroDescribeImageResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroDescribeImageResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroDescribeImageResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroDescribeImageResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldDescription = clazz->getField("description"); + jni::local_ref description = this->getFieldValue(fieldDescription); + static const auto fieldConfidence = clazz->getField("confidence"); + double confidence = this->getFieldValue(fieldConfidence); + return NitroDescribeImageResult( + description->toStdString(), + confidence + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroDescribeImageResult& value) { + using JSignature = JNitroDescribeImageResult(jni::alias_ref, double); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.description), + value.confidence + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDeviceCapability.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDeviceCapability.hpp new file mode 100644 index 0000000..5bc6f51 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroDeviceCapability.hpp @@ -0,0 +1,106 @@ +/// +/// JNitroDeviceCapability.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroDeviceCapability.hpp" + +#include "JOndeviceAiPlatform.hpp" +#include "OndeviceAiPlatform.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroDeviceCapability" and the the Kotlin data class "NitroDeviceCapability". + */ + struct JNitroDeviceCapability final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroDeviceCapability;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroDeviceCapability by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroDeviceCapability toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldIsSupported = clazz->getField("isSupported"); + jboolean isSupported = this->getFieldValue(fieldIsSupported); + static const auto fieldIsModelReady = clazz->getField("isModelReady"); + jboolean isModelReady = this->getFieldValue(fieldIsModelReady); + static const auto fieldSupportsAppleIntelligence = clazz->getField("supportsAppleIntelligence"); + jboolean supportsAppleIntelligence = this->getFieldValue(fieldSupportsAppleIntelligence); + static const auto fieldPlatform = clazz->getField("platform"); + jni::local_ref platform = this->getFieldValue(fieldPlatform); + static const auto fieldFeatureSummarize = clazz->getField("featureSummarize"); + jboolean featureSummarize = this->getFieldValue(fieldFeatureSummarize); + static const auto fieldFeatureClassify = clazz->getField("featureClassify"); + jboolean featureClassify = this->getFieldValue(fieldFeatureClassify); + static const auto fieldFeatureExtract = clazz->getField("featureExtract"); + jboolean featureExtract = this->getFieldValue(fieldFeatureExtract); + static const auto fieldFeatureChat = clazz->getField("featureChat"); + jboolean featureChat = this->getFieldValue(fieldFeatureChat); + static const auto fieldFeatureTranslate = clazz->getField("featureTranslate"); + jboolean featureTranslate = this->getFieldValue(fieldFeatureTranslate); + static const auto fieldFeatureRewrite = clazz->getField("featureRewrite"); + jboolean featureRewrite = this->getFieldValue(fieldFeatureRewrite); + static const auto fieldFeatureProofread = clazz->getField("featureProofread"); + jboolean featureProofread = this->getFieldValue(fieldFeatureProofread); + static const auto fieldAvailableMemoryMB = clazz->getField("availableMemoryMB"); + double availableMemoryMB = this->getFieldValue(fieldAvailableMemoryMB); + static const auto fieldIsLowPowerMode = clazz->getField("isLowPowerMode"); + jboolean isLowPowerMode = this->getFieldValue(fieldIsLowPowerMode); + return NitroDeviceCapability( + static_cast(isSupported), + static_cast(isModelReady), + static_cast(supportsAppleIntelligence), + platform->toCpp(), + static_cast(featureSummarize), + static_cast(featureClassify), + static_cast(featureExtract), + static_cast(featureChat), + static_cast(featureTranslate), + static_cast(featureRewrite), + static_cast(featureProofread), + availableMemoryMB, + static_cast(isLowPowerMode) + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroDeviceCapability& value) { + using JSignature = JNitroDeviceCapability(jboolean, jboolean, jboolean, jni::alias_ref, jboolean, jboolean, jboolean, jboolean, jboolean, jboolean, jboolean, double, jboolean); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + value.isSupported, + value.isModelReady, + value.supportsAppleIntelligence, + JOndeviceAiPlatform::fromCpp(value.platform), + value.featureSummarize, + value.featureClassify, + value.featureExtract, + value.featureChat, + value.featureTranslate, + value.featureRewrite, + value.featureProofread, + value.availableMemoryMB, + value.isLowPowerMode + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractEntity.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractEntity.hpp new file mode 100644 index 0000000..28a8baa --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractEntity.hpp @@ -0,0 +1,73 @@ +/// +/// JNitroExtractEntity.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroExtractEntity.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroExtractEntity" and the the Kotlin data class "NitroExtractEntity". + */ + struct JNitroExtractEntity final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroExtractEntity;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroExtractEntity by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroExtractEntity toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldType = clazz->getField("type"); + jni::local_ref type = this->getFieldValue(fieldType); + static const auto fieldValue = clazz->getField("value"); + jni::local_ref value = this->getFieldValue(fieldValue); + static const auto fieldConfidence = clazz->getField("confidence"); + double confidence = this->getFieldValue(fieldConfidence); + static const auto fieldStartPos = clazz->getField("startPos"); + double startPos = this->getFieldValue(fieldStartPos); + static const auto fieldEndPos = clazz->getField("endPos"); + double endPos = this->getFieldValue(fieldEndPos); + return NitroExtractEntity( + type->toStdString(), + value->toStdString(), + confidence, + startPos, + endPos + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroExtractEntity& value) { + using JSignature = JNitroExtractEntity(jni::alias_ref, jni::alias_ref, double, double, double); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.type), + jni::make_jstring(value.value), + value.confidence, + value.startPos, + value.endPos + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractOptions.hpp new file mode 100644 index 0000000..7100ad2 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractOptions.hpp @@ -0,0 +1,63 @@ +/// +/// JNitroExtractOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroExtractOptions.hpp" + +#include "JVariant_NullType_Array_String_.hpp" +#include +#include +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroExtractOptions" and the the Kotlin data class "NitroExtractOptions". + */ + struct JNitroExtractOptions final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroExtractOptions;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroExtractOptions by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroExtractOptions toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldEntityTypes = clazz->getField("entityTypes"); + jni::local_ref entityTypes = this->getFieldValue(fieldEntityTypes); + return NitroExtractOptions( + entityTypes != nullptr ? std::make_optional(entityTypes->toCpp()) : std::nullopt + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroExtractOptions& value) { + using JSignature = JNitroExtractOptions(jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + value.entityTypes.has_value() ? JVariant_NullType_Array_String_::fromCpp(value.entityTypes.value()) : nullptr + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractResult.hpp new file mode 100644 index 0000000..9681be3 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroExtractResult.hpp @@ -0,0 +1,78 @@ +/// +/// JNitroExtractResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroExtractResult.hpp" + +#include "JNitroExtractEntity.hpp" +#include "NitroExtractEntity.hpp" +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroExtractResult" and the the Kotlin data class "NitroExtractResult". + */ + struct JNitroExtractResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroExtractResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroExtractResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroExtractResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldEntities = clazz->getField>("entities"); + jni::local_ref> entities = this->getFieldValue(fieldEntities); + return NitroExtractResult( + [&]() { + size_t __size = entities->size(); + std::vector __vector; + __vector.reserve(__size); + for (size_t __i = 0; __i < __size; __i++) { + auto __element = entities->getElement(__i); + __vector.push_back(__element->toCpp()); + } + return __vector; + }() + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroExtractResult& value) { + using JSignature = JNitroExtractResult(jni::alias_ref>); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + [&]() { + size_t __size = value.entities.size(); + jni::local_ref> __array = jni::JArrayClass::newArray(__size); + for (size_t __i = 0; __i < __size; __i++) { + const auto& __element = value.entities[__i]; + auto __elementJni = JNitroExtractEntity::fromCpp(__element); + __array->setElement(__i, *__elementJni); + } + return __array; + }() + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroInferenceEngine.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroInferenceEngine.hpp new file mode 100644 index 0000000..5005097 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroInferenceEngine.hpp @@ -0,0 +1,71 @@ +/// +/// JNitroInferenceEngine.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroInferenceEngine.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "NitroInferenceEngine" and the the Kotlin enum "NitroInferenceEngine". + */ + struct JNitroInferenceEngine final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroInferenceEngine;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum NitroInferenceEngine. + */ + [[maybe_unused]] + [[nodiscard]] + NitroInferenceEngine toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(NitroInferenceEngine value) { + static const auto clazz = javaClassStatic(); + static const auto fieldFOUNDATION_MODELS = clazz->getStaticField("FOUNDATION_MODELS"); + static const auto fieldLLAMA_CPP = clazz->getStaticField("LLAMA_CPP"); + static const auto fieldMLX = clazz->getStaticField("MLX"); + static const auto fieldCORE_ML = clazz->getStaticField("CORE_ML"); + static const auto fieldPROMPT_API = clazz->getStaticField("PROMPT_API"); + static const auto fieldNONE = clazz->getStaticField("NONE"); + + switch (value) { + case NitroInferenceEngine::FOUNDATION_MODELS: + return clazz->getStaticFieldValue(fieldFOUNDATION_MODELS); + case NitroInferenceEngine::LLAMA_CPP: + return clazz->getStaticFieldValue(fieldLLAMA_CPP); + case NitroInferenceEngine::MLX: + return clazz->getStaticFieldValue(fieldMLX); + case NitroInferenceEngine::CORE_ML: + return clazz->getStaticFieldValue(fieldCORE_ML); + case NitroInferenceEngine::PROMPT_API: + return clazz->getStaticFieldValue(fieldPROMPT_API); + case NitroInferenceEngine::NONE: + return clazz->getStaticFieldValue(fieldNONE); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelDownloadProgress.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelDownloadProgress.hpp new file mode 100644 index 0000000..30bd9b4 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelDownloadProgress.hpp @@ -0,0 +1,75 @@ +/// +/// JNitroModelDownloadProgress.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroModelDownloadProgress.hpp" + +#include "JNitroModelDownloadState.hpp" +#include "NitroModelDownloadState.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroModelDownloadProgress" and the the Kotlin data class "NitroModelDownloadProgress". + */ + struct JNitroModelDownloadProgress final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroModelDownloadProgress;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroModelDownloadProgress by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroModelDownloadProgress toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldModelId = clazz->getField("modelId"); + jni::local_ref modelId = this->getFieldValue(fieldModelId); + static const auto fieldBytesDownloaded = clazz->getField("bytesDownloaded"); + double bytesDownloaded = this->getFieldValue(fieldBytesDownloaded); + static const auto fieldTotalBytes = clazz->getField("totalBytes"); + double totalBytes = this->getFieldValue(fieldTotalBytes); + static const auto fieldProgress = clazz->getField("progress"); + double progress = this->getFieldValue(fieldProgress); + static const auto fieldState = clazz->getField("state"); + jni::local_ref state = this->getFieldValue(fieldState); + return NitroModelDownloadProgress( + modelId->toStdString(), + bytesDownloaded, + totalBytes, + progress, + state->toCpp() + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroModelDownloadProgress& value) { + using JSignature = JNitroModelDownloadProgress(jni::alias_ref, double, double, double, jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.modelId), + value.bytesDownloaded, + value.totalBytes, + value.progress, + JNitroModelDownloadState::fromCpp(value.state) + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelDownloadState.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelDownloadState.hpp new file mode 100644 index 0000000..434950d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelDownloadState.hpp @@ -0,0 +1,71 @@ +/// +/// JNitroModelDownloadState.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroModelDownloadState.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "NitroModelDownloadState" and the the Kotlin enum "NitroModelDownloadState". + */ + struct JNitroModelDownloadState final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroModelDownloadState;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum NitroModelDownloadState. + */ + [[maybe_unused]] + [[nodiscard]] + NitroModelDownloadState toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(NitroModelDownloadState value) { + static const auto clazz = javaClassStatic(); + static const auto fieldPENDING = clazz->getStaticField("PENDING"); + static const auto fieldDOWNLOADING = clazz->getStaticField("DOWNLOADING"); + static const auto fieldVERIFYING = clazz->getStaticField("VERIFYING"); + static const auto fieldCOMPLETED = clazz->getStaticField("COMPLETED"); + static const auto fieldFAILED = clazz->getStaticField("FAILED"); + static const auto fieldCANCELLED = clazz->getStaticField("CANCELLED"); + + switch (value) { + case NitroModelDownloadState::PENDING: + return clazz->getStaticFieldValue(fieldPENDING); + case NitroModelDownloadState::DOWNLOADING: + return clazz->getStaticFieldValue(fieldDOWNLOADING); + case NitroModelDownloadState::VERIFYING: + return clazz->getStaticFieldValue(fieldVERIFYING); + case NitroModelDownloadState::COMPLETED: + return clazz->getStaticFieldValue(fieldCOMPLETED); + case NitroModelDownloadState::FAILED: + return clazz->getStaticFieldValue(fieldFAILED); + case NitroModelDownloadState::CANCELLED: + return clazz->getStaticFieldValue(fieldCANCELLED); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelInfo.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelInfo.hpp new file mode 100644 index 0000000..dd1c381 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroModelInfo.hpp @@ -0,0 +1,85 @@ +/// +/// JNitroModelInfo.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroModelInfo.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroModelInfo" and the the Kotlin data class "NitroModelInfo". + */ + struct JNitroModelInfo final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroModelInfo;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroModelInfo by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroModelInfo toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldModelId = clazz->getField("modelId"); + jni::local_ref modelId = this->getFieldValue(fieldModelId); + static const auto fieldName = clazz->getField("name"); + jni::local_ref name = this->getFieldValue(fieldName); + static const auto fieldVersion = clazz->getField("version"); + jni::local_ref version = this->getFieldValue(fieldVersion); + static const auto fieldSizeMB = clazz->getField("sizeMB"); + double sizeMB = this->getFieldValue(fieldSizeMB); + static const auto fieldQuantization = clazz->getField("quantization"); + jni::local_ref quantization = this->getFieldValue(fieldQuantization); + static const auto fieldContextLength = clazz->getField("contextLength"); + double contextLength = this->getFieldValue(fieldContextLength); + static const auto fieldMinMemoryMB = clazz->getField("minMemoryMB"); + double minMemoryMB = this->getFieldValue(fieldMinMemoryMB); + static const auto fieldIsMultimodal = clazz->getField("isMultimodal"); + jboolean isMultimodal = this->getFieldValue(fieldIsMultimodal); + return NitroModelInfo( + modelId->toStdString(), + name->toStdString(), + version->toStdString(), + sizeMB, + quantization->toStdString(), + contextLength, + minMemoryMB, + static_cast(isMultimodal) + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroModelInfo& value) { + using JSignature = JNitroModelInfo(jni::alias_ref, jni::alias_ref, jni::alias_ref, double, jni::alias_ref, double, double, jboolean); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.modelId), + jni::make_jstring(value.name), + jni::make_jstring(value.version), + value.sizeMB, + jni::make_jstring(value.quantization), + value.contextLength, + value.minMemoryMB, + value.isMultimodal + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroProofreadCorrection.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroProofreadCorrection.hpp new file mode 100644 index 0000000..1abc83e --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroProofreadCorrection.hpp @@ -0,0 +1,77 @@ +/// +/// JNitroProofreadCorrection.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroProofreadCorrection.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroProofreadCorrection" and the the Kotlin data class "NitroProofreadCorrection". + */ + struct JNitroProofreadCorrection final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroProofreadCorrection;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroProofreadCorrection by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroProofreadCorrection toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOriginal = clazz->getField("original"); + jni::local_ref original = this->getFieldValue(fieldOriginal); + static const auto fieldCorrected = clazz->getField("corrected"); + jni::local_ref corrected = this->getFieldValue(fieldCorrected); + static const auto fieldType = clazz->getField("type"); + jni::local_ref type = this->getFieldValue(fieldType); + static const auto fieldConfidence = clazz->getField("confidence"); + double confidence = this->getFieldValue(fieldConfidence); + static const auto fieldStartPos = clazz->getField("startPos"); + double startPos = this->getFieldValue(fieldStartPos); + static const auto fieldEndPos = clazz->getField("endPos"); + double endPos = this->getFieldValue(fieldEndPos); + return NitroProofreadCorrection( + original->toStdString(), + corrected->toStdString(), + type->toStdString(), + confidence, + startPos, + endPos + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroProofreadCorrection& value) { + using JSignature = JNitroProofreadCorrection(jni::alias_ref, jni::alias_ref, jni::alias_ref, double, double, double); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.original), + jni::make_jstring(value.corrected), + jni::make_jstring(value.type), + value.confidence, + value.startPos, + value.endPos + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroProofreadResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroProofreadResult.hpp new file mode 100644 index 0000000..a45553d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroProofreadResult.hpp @@ -0,0 +1,86 @@ +/// +/// JNitroProofreadResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroProofreadResult.hpp" + +#include "JNitroProofreadCorrection.hpp" +#include "NitroProofreadCorrection.hpp" +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroProofreadResult" and the the Kotlin data class "NitroProofreadResult". + */ + struct JNitroProofreadResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroProofreadResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroProofreadResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroProofreadResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldCorrectedText = clazz->getField("correctedText"); + jni::local_ref correctedText = this->getFieldValue(fieldCorrectedText); + static const auto fieldCorrections = clazz->getField>("corrections"); + jni::local_ref> corrections = this->getFieldValue(fieldCorrections); + static const auto fieldHasCorrections = clazz->getField("hasCorrections"); + jboolean hasCorrections = this->getFieldValue(fieldHasCorrections); + return NitroProofreadResult( + correctedText->toStdString(), + [&]() { + size_t __size = corrections->size(); + std::vector __vector; + __vector.reserve(__size); + for (size_t __i = 0; __i < __size; __i++) { + auto __element = corrections->getElement(__i); + __vector.push_back(__element->toCpp()); + } + return __vector; + }(), + static_cast(hasCorrections) + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroProofreadResult& value) { + using JSignature = JNitroProofreadResult(jni::alias_ref, jni::alias_ref>, jboolean); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.correctedText), + [&]() { + size_t __size = value.corrections.size(); + jni::local_ref> __array = jni::JArrayClass::newArray(__size); + for (size_t __i = 0; __i < __size; __i++) { + const auto& __element = value.corrections[__i]; + auto __elementJni = JNitroProofreadCorrection::fromCpp(__element); + __array->setElement(__i, *__elementJni); + } + return __array; + }(), + value.hasCorrections + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteOptions.hpp new file mode 100644 index 0000000..e191e48 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteOptions.hpp @@ -0,0 +1,58 @@ +/// +/// JNitroRewriteOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroRewriteOptions.hpp" + +#include "JNitroRewriteOutputType.hpp" +#include "NitroRewriteOutputType.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroRewriteOptions" and the the Kotlin data class "NitroRewriteOptions". + */ + struct JNitroRewriteOptions final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroRewriteOptions;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroRewriteOptions by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroRewriteOptions toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOutputType = clazz->getField("outputType"); + jni::local_ref outputType = this->getFieldValue(fieldOutputType); + return NitroRewriteOptions( + outputType->toCpp() + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroRewriteOptions& value) { + using JSignature = JNitroRewriteOptions(jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + JNitroRewriteOutputType::fromCpp(value.outputType) + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteOutputType.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteOutputType.hpp new file mode 100644 index 0000000..6f4c4bd --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteOutputType.hpp @@ -0,0 +1,71 @@ +/// +/// JNitroRewriteOutputType.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroRewriteOutputType.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "NitroRewriteOutputType" and the the Kotlin enum "NitroRewriteOutputType". + */ + struct JNitroRewriteOutputType final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroRewriteOutputType;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum NitroRewriteOutputType. + */ + [[maybe_unused]] + [[nodiscard]] + NitroRewriteOutputType toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(NitroRewriteOutputType value) { + static const auto clazz = javaClassStatic(); + static const auto fieldELABORATE = clazz->getStaticField("ELABORATE"); + static const auto fieldEMOJIFY = clazz->getStaticField("EMOJIFY"); + static const auto fieldSHORTEN = clazz->getStaticField("SHORTEN"); + static const auto fieldFRIENDLY = clazz->getStaticField("FRIENDLY"); + static const auto fieldPROFESSIONAL = clazz->getStaticField("PROFESSIONAL"); + static const auto fieldREPHRASE = clazz->getStaticField("REPHRASE"); + + switch (value) { + case NitroRewriteOutputType::ELABORATE: + return clazz->getStaticFieldValue(fieldELABORATE); + case NitroRewriteOutputType::EMOJIFY: + return clazz->getStaticFieldValue(fieldEMOJIFY); + case NitroRewriteOutputType::SHORTEN: + return clazz->getStaticFieldValue(fieldSHORTEN); + case NitroRewriteOutputType::FRIENDLY: + return clazz->getStaticFieldValue(fieldFRIENDLY); + case NitroRewriteOutputType::PROFESSIONAL: + return clazz->getStaticFieldValue(fieldPROFESSIONAL); + case NitroRewriteOutputType::REPHRASE: + return clazz->getStaticFieldValue(fieldREPHRASE); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteResult.hpp new file mode 100644 index 0000000..2ec5a44 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroRewriteResult.hpp @@ -0,0 +1,65 @@ +/// +/// JNitroRewriteResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroRewriteResult.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroRewriteResult" and the the Kotlin data class "NitroRewriteResult". + */ + struct JNitroRewriteResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroRewriteResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroRewriteResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroRewriteResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldRewrittenText = clazz->getField("rewrittenText"); + jni::local_ref rewrittenText = this->getFieldValue(fieldRewrittenText); + static const auto fieldStyle = clazz->getField("style"); + jni::local_ref style = this->getFieldValue(fieldStyle); + static const auto fieldConfidence = clazz->getField("confidence"); + double confidence = this->getFieldValue(fieldConfidence); + return NitroRewriteResult( + rewrittenText->toStdString(), + style->toStdString(), + confidence + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroRewriteResult& value) { + using JSignature = JNitroRewriteResult(jni::alias_ref, jni::alias_ref, double); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.rewrittenText), + jni::make_jstring(value.style), + value.confidence + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeInputType.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeInputType.hpp new file mode 100644 index 0000000..5948ade --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeInputType.hpp @@ -0,0 +1,59 @@ +/// +/// JNitroSummarizeInputType.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroSummarizeInputType.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "NitroSummarizeInputType" and the the Kotlin enum "NitroSummarizeInputType". + */ + struct JNitroSummarizeInputType final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroSummarizeInputType;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum NitroSummarizeInputType. + */ + [[maybe_unused]] + [[nodiscard]] + NitroSummarizeInputType toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(NitroSummarizeInputType value) { + static const auto clazz = javaClassStatic(); + static const auto fieldARTICLE = clazz->getStaticField("ARTICLE"); + static const auto fieldCONVERSATION = clazz->getStaticField("CONVERSATION"); + + switch (value) { + case NitroSummarizeInputType::ARTICLE: + return clazz->getStaticFieldValue(fieldARTICLE); + case NitroSummarizeInputType::CONVERSATION: + return clazz->getStaticFieldValue(fieldCONVERSATION); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeOptions.hpp new file mode 100644 index 0000000..2d48a76 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeOptions.hpp @@ -0,0 +1,65 @@ +/// +/// JNitroSummarizeOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroSummarizeOptions.hpp" + +#include "JNitroSummarizeInputType.hpp" +#include "JNitroSummarizeOutputType.hpp" +#include "NitroSummarizeInputType.hpp" +#include "NitroSummarizeOutputType.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroSummarizeOptions" and the the Kotlin data class "NitroSummarizeOptions". + */ + struct JNitroSummarizeOptions final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroSummarizeOptions;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroSummarizeOptions by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroSummarizeOptions toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldInputType = clazz->getField("inputType"); + jni::local_ref inputType = this->getFieldValue(fieldInputType); + static const auto fieldOutputType = clazz->getField("outputType"); + jni::local_ref outputType = this->getFieldValue(fieldOutputType); + return NitroSummarizeOptions( + inputType != nullptr ? std::make_optional(inputType->toCpp()) : std::nullopt, + outputType != nullptr ? std::make_optional(outputType->toCpp()) : std::nullopt + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroSummarizeOptions& value) { + using JSignature = JNitroSummarizeOptions(jni::alias_ref, jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + value.inputType.has_value() ? JNitroSummarizeInputType::fromCpp(value.inputType.value()) : nullptr, + value.outputType.has_value() ? JNitroSummarizeOutputType::fromCpp(value.outputType.value()) : nullptr + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeOutputType.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeOutputType.hpp new file mode 100644 index 0000000..b56ab92 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeOutputType.hpp @@ -0,0 +1,62 @@ +/// +/// JNitroSummarizeOutputType.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroSummarizeOutputType.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "NitroSummarizeOutputType" and the the Kotlin enum "NitroSummarizeOutputType". + */ + struct JNitroSummarizeOutputType final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroSummarizeOutputType;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum NitroSummarizeOutputType. + */ + [[maybe_unused]] + [[nodiscard]] + NitroSummarizeOutputType toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(NitroSummarizeOutputType value) { + static const auto clazz = javaClassStatic(); + static const auto fieldONE_BULLET = clazz->getStaticField("ONE_BULLET"); + static const auto fieldTWO_BULLETS = clazz->getStaticField("TWO_BULLETS"); + static const auto fieldTHREE_BULLETS = clazz->getStaticField("THREE_BULLETS"); + + switch (value) { + case NitroSummarizeOutputType::ONE_BULLET: + return clazz->getStaticFieldValue(fieldONE_BULLET); + case NitroSummarizeOutputType::TWO_BULLETS: + return clazz->getStaticFieldValue(fieldTWO_BULLETS); + case NitroSummarizeOutputType::THREE_BULLETS: + return clazz->getStaticFieldValue(fieldTHREE_BULLETS); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeResult.hpp new file mode 100644 index 0000000..6bdca97 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroSummarizeResult.hpp @@ -0,0 +1,69 @@ +/// +/// JNitroSummarizeResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroSummarizeResult.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroSummarizeResult" and the the Kotlin data class "NitroSummarizeResult". + */ + struct JNitroSummarizeResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroSummarizeResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroSummarizeResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroSummarizeResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldSummary = clazz->getField("summary"); + jni::local_ref summary = this->getFieldValue(fieldSummary); + static const auto fieldOriginalLength = clazz->getField("originalLength"); + double originalLength = this->getFieldValue(fieldOriginalLength); + static const auto fieldSummaryLength = clazz->getField("summaryLength"); + double summaryLength = this->getFieldValue(fieldSummaryLength); + static const auto fieldConfidence = clazz->getField("confidence"); + double confidence = this->getFieldValue(fieldConfidence); + return NitroSummarizeResult( + summary->toStdString(), + originalLength, + summaryLength, + confidence + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroSummarizeResult& value) { + using JSignature = JNitroSummarizeResult(jni::alias_ref, double, double, double); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.summary), + value.originalLength, + value.summaryLength, + value.confidence + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTextStreamChunk.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTextStreamChunk.hpp new file mode 100644 index 0000000..c023572 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTextStreamChunk.hpp @@ -0,0 +1,65 @@ +/// +/// JNitroTextStreamChunk.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroTextStreamChunk.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroTextStreamChunk" and the the Kotlin data class "NitroTextStreamChunk". + */ + struct JNitroTextStreamChunk final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroTextStreamChunk;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroTextStreamChunk by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroTextStreamChunk toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldDelta = clazz->getField("delta"); + jni::local_ref delta = this->getFieldValue(fieldDelta); + static const auto fieldAccumulated = clazz->getField("accumulated"); + jni::local_ref accumulated = this->getFieldValue(fieldAccumulated); + static const auto fieldIsFinal = clazz->getField("isFinal"); + jboolean isFinal = this->getFieldValue(fieldIsFinal); + return NitroTextStreamChunk( + delta->toStdString(), + accumulated->toStdString(), + static_cast(isFinal) + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroTextStreamChunk& value) { + using JSignature = JNitroTextStreamChunk(jni::alias_ref, jni::alias_ref, jboolean); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.delta), + jni::make_jstring(value.accumulated), + value.isFinal + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTranslateOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTranslateOptions.hpp new file mode 100644 index 0000000..3a0fdf4 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTranslateOptions.hpp @@ -0,0 +1,61 @@ +/// +/// JNitroTranslateOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroTranslateOptions.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroTranslateOptions" and the the Kotlin data class "NitroTranslateOptions". + */ + struct JNitroTranslateOptions final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroTranslateOptions;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroTranslateOptions by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroTranslateOptions toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldSourceLanguage = clazz->getField("sourceLanguage"); + jni::local_ref sourceLanguage = this->getFieldValue(fieldSourceLanguage); + static const auto fieldTargetLanguage = clazz->getField("targetLanguage"); + jni::local_ref targetLanguage = this->getFieldValue(fieldTargetLanguage); + return NitroTranslateOptions( + sourceLanguage->toStdString(), + targetLanguage->toStdString() + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroTranslateOptions& value) { + using JSignature = JNitroTranslateOptions(jni::alias_ref, jni::alias_ref); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.sourceLanguage), + jni::make_jstring(value.targetLanguage) + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTranslateResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTranslateResult.hpp new file mode 100644 index 0000000..b91ac0a --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JNitroTranslateResult.hpp @@ -0,0 +1,69 @@ +/// +/// JNitroTranslateResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "NitroTranslateResult.hpp" + +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ struct "NitroTranslateResult" and the the Kotlin data class "NitroTranslateResult". + */ + struct JNitroTranslateResult final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/NitroTranslateResult;"; + + public: + /** + * Convert this Java/Kotlin-based struct to the C++ struct NitroTranslateResult by copying all values to C++. + */ + [[maybe_unused]] + [[nodiscard]] + NitroTranslateResult toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldTranslatedText = clazz->getField("translatedText"); + jni::local_ref translatedText = this->getFieldValue(fieldTranslatedText); + static const auto fieldSourceLanguage = clazz->getField("sourceLanguage"); + jni::local_ref sourceLanguage = this->getFieldValue(fieldSourceLanguage); + static const auto fieldTargetLanguage = clazz->getField("targetLanguage"); + jni::local_ref targetLanguage = this->getFieldValue(fieldTargetLanguage); + static const auto fieldConfidence = clazz->getField("confidence"); + double confidence = this->getFieldValue(fieldConfidence); + return NitroTranslateResult( + translatedText->toStdString(), + sourceLanguage->toStdString(), + targetLanguage->toStdString(), + confidence + ); + } + + public: + /** + * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java. + */ + [[maybe_unused]] + static jni::local_ref fromCpp(const NitroTranslateResult& value) { + using JSignature = JNitroTranslateResult(jni::alias_ref, jni::alias_ref, jni::alias_ref, double); + static const auto clazz = javaClassStatic(); + static const auto create = clazz->getStaticMethod("fromCpp"); + return create( + clazz, + jni::make_jstring(value.translatedText), + jni::make_jstring(value.sourceLanguage), + jni::make_jstring(value.targetLanguage), + value.confidence + ); + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JOndeviceAiPlatform.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JOndeviceAiPlatform.hpp new file mode 100644 index 0000000..4b1caf2 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JOndeviceAiPlatform.hpp @@ -0,0 +1,59 @@ +/// +/// JOndeviceAiPlatform.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "OndeviceAiPlatform.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "OndeviceAiPlatform" and the the Kotlin enum "OndeviceAiPlatform". + */ + struct JOndeviceAiPlatform final: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/OndeviceAiPlatform;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum OndeviceAiPlatform. + */ + [[maybe_unused]] + [[nodiscard]] + OndeviceAiPlatform toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(OndeviceAiPlatform value) { + static const auto clazz = javaClassStatic(); + static const auto fieldAPPLE = clazz->getStaticField("APPLE"); + static const auto fieldGOOGLE = clazz->getStaticField("GOOGLE"); + + switch (value) { + case OndeviceAiPlatform::APPLE: + return clazz->getStaticFieldValue(fieldAPPLE); + case OndeviceAiPlatform::GOOGLE: + return clazz->getStaticFieldValue(fieldGOOGLE); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_NitroChatMessage_.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_NitroChatMessage_.cpp new file mode 100644 index 0000000..51a9353 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_NitroChatMessage_.cpp @@ -0,0 +1,35 @@ +/// +/// JVariant_NullType_Array_NitroChatMessage_.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_Array_NitroChatMessage_.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_Array_NitroChatMessage_ to std::variant> + */ + std::variant> JVariant_NullType_Array_NitroChatMessage_::toCpp() const { + if (isInstanceOf(JVariant_NullType_Array_NitroChatMessage__impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_Array_NitroChatMessage__impl::Second::javaClassStatic())) { + // It's a `std::vector` + auto jniValue = static_cast(this)->getValue(); + return [&]() { + size_t __size = jniValue->size(); + std::vector __vector; + __vector.reserve(__size); + for (size_t __i = 0; __i < __size; __i++) { + auto __element = jniValue->getElement(__i); + __vector.push_back(__element->toCpp()); + } + return __vector; + }(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_NitroChatMessage_.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_NitroChatMessage_.hpp new file mode 100644 index 0000000..8605ed7 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_NitroChatMessage_.hpp @@ -0,0 +1,84 @@ +/// +/// JVariant_NullType_Array_NitroChatMessage_.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include "NitroChatMessage.hpp" +#include +#include +#include +#include "JNitroChatMessage.hpp" +#include "NitroChatMessageRole.hpp" +#include "JNitroChatMessageRole.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Array_NitroChatMessage_". + */ + class JVariant_NullType_Array_NitroChatMessage_: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Array_NitroChatMessage_;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref> value) { + static const auto method = javaClassStatic()->getStaticMethod>)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant>& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1([&]() { + size_t __size = std::get<1>(variant).size(); + jni::local_ref> __array = jni::JArrayClass::newArray(__size); + for (size_t __i = 0; __i < __size; __i++) { + const auto& __element = std::get<1>(variant)[__i]; + auto __elementJni = JNitroChatMessage::fromCpp(__element); + __array->setElement(__i, *__elementJni); + } + return __array; + }()); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant> toCpp() const; + }; + + namespace JVariant_NullType_Array_NitroChatMessage__impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Array_NitroChatMessage_$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Array_NitroChatMessage_$Second;"; + + [[nodiscard]] jni::local_ref> getValue() const { + static const auto field = javaClassStatic()->getField>("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_Array_NitroChatMessage__impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_String_.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_String_.cpp new file mode 100644 index 0000000..1fcb7d6 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_String_.cpp @@ -0,0 +1,35 @@ +/// +/// JVariant_NullType_Array_String_.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_Array_String_.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_Array_String_ to std::variant> + */ + std::variant> JVariant_NullType_Array_String_::toCpp() const { + if (isInstanceOf(JVariant_NullType_Array_String__impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_Array_String__impl::Second::javaClassStatic())) { + // It's a `std::vector` + auto jniValue = static_cast(this)->getValue(); + return [&]() { + size_t __size = jniValue->size(); + std::vector __vector; + __vector.reserve(__size); + for (size_t __i = 0; __i < __size; __i++) { + auto __element = jniValue->getElement(__i); + __vector.push_back(__element->toStdString()); + } + return __vector; + }(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_String_.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_String_.hpp new file mode 100644 index 0000000..d218ef0 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Array_String_.hpp @@ -0,0 +1,80 @@ +/// +/// JVariant_NullType_Array_String_.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Array_String_". + */ + class JVariant_NullType_Array_String_: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Array_String_;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref> value) { + static const auto method = javaClassStatic()->getStaticMethod>)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant>& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1([&]() { + size_t __size = std::get<1>(variant).size(); + jni::local_ref> __array = jni::JArrayClass::newArray(__size); + for (size_t __i = 0; __i < __size; __i++) { + const auto& __element = std::get<1>(variant)[__i]; + auto __elementJni = jni::make_jstring(__element); + __array->setElement(__i, *__elementJni); + } + return __array; + }()); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant> toCpp() const; + }; + + namespace JVariant_NullType_Array_String__impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Array_String_$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Array_String_$Second;"; + + [[nodiscard]] jni::local_ref> getValue() const { + static const auto field = javaClassStatic()->getField>("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_Array_String__impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Double.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Double.cpp new file mode 100644 index 0000000..0c68d79 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Double.cpp @@ -0,0 +1,26 @@ +/// +/// JVariant_NullType_Double.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_Double.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_Double to std::variant + */ + std::variant JVariant_NullType_Double::toCpp() const { + if (isInstanceOf(JVariant_NullType_Double_impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_Double_impl::Second::javaClassStatic())) { + // It's a `double` + auto jniValue = static_cast(this)->getValue(); + return jniValue; + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Double.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Double.hpp new file mode 100644 index 0000000..9593b27 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_Double.hpp @@ -0,0 +1,69 @@ +/// +/// JVariant_NullType_Double.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Double". + */ + class JVariant_NullType_Double: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Double;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(double value) { + static const auto method = javaClassStatic()->getStaticMethod("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1(std::get<1>(variant)); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant toCpp() const; + }; + + namespace JVariant_NullType_Double_impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Double$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_Double$Second;"; + + [[nodiscard]] double getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_Double_impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroChatOptions.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroChatOptions.cpp new file mode 100644 index 0000000..5467c1d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroChatOptions.cpp @@ -0,0 +1,26 @@ +/// +/// JVariant_NullType_NitroChatOptions.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_NitroChatOptions.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_NitroChatOptions to std::variant + */ + std::variant JVariant_NullType_NitroChatOptions::toCpp() const { + if (isInstanceOf(JVariant_NullType_NitroChatOptions_impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_NitroChatOptions_impl::Second::javaClassStatic())) { + // It's a `NitroChatOptions` + auto jniValue = static_cast(this)->getValue(); + return jniValue->toCpp(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroChatOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroChatOptions.hpp new file mode 100644 index 0000000..4538677 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroChatOptions.hpp @@ -0,0 +1,80 @@ +/// +/// JVariant_NullType_NitroChatOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include "NitroChatOptions.hpp" +#include +#include +#include "JNitroChatOptions.hpp" +#include +#include +#include "JVariant_NullType_String.hpp" +#include "NitroChatMessage.hpp" +#include +#include "JVariant_NullType_Array_NitroChatMessage_.hpp" +#include "JNitroChatMessage.hpp" +#include "NitroChatMessageRole.hpp" +#include "JNitroChatMessageRole.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_NitroChatOptions". + */ + class JVariant_NullType_NitroChatOptions: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroChatOptions;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1(JNitroChatOptions::fromCpp(std::get<1>(variant))); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant toCpp() const; + }; + + namespace JVariant_NullType_NitroChatOptions_impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroChatOptions$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroChatOptions$Second;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_NitroChatOptions_impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroClassifyOptions.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroClassifyOptions.cpp new file mode 100644 index 0000000..82e180d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroClassifyOptions.cpp @@ -0,0 +1,26 @@ +/// +/// JVariant_NullType_NitroClassifyOptions.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_NitroClassifyOptions.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_NitroClassifyOptions to std::variant + */ + std::variant JVariant_NullType_NitroClassifyOptions::toCpp() const { + if (isInstanceOf(JVariant_NullType_NitroClassifyOptions_impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_NitroClassifyOptions_impl::Second::javaClassStatic())) { + // It's a `NitroClassifyOptions` + auto jniValue = static_cast(this)->getValue(); + return jniValue->toCpp(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroClassifyOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroClassifyOptions.hpp new file mode 100644 index 0000000..c89e147 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroClassifyOptions.hpp @@ -0,0 +1,76 @@ +/// +/// JVariant_NullType_NitroClassifyOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include "NitroClassifyOptions.hpp" +#include +#include +#include "JNitroClassifyOptions.hpp" +#include +#include +#include +#include "JVariant_NullType_Array_String_.hpp" +#include "JVariant_NullType_Double.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_NitroClassifyOptions". + */ + class JVariant_NullType_NitroClassifyOptions: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroClassifyOptions;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1(JNitroClassifyOptions::fromCpp(std::get<1>(variant))); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant toCpp() const; + }; + + namespace JVariant_NullType_NitroClassifyOptions_impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroClassifyOptions$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroClassifyOptions$Second;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_NitroClassifyOptions_impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroDescribeImageOptions.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroDescribeImageOptions.cpp new file mode 100644 index 0000000..762be5a --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroDescribeImageOptions.cpp @@ -0,0 +1,26 @@ +/// +/// JVariant_NullType_NitroDescribeImageOptions.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_NitroDescribeImageOptions.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_NitroDescribeImageOptions to std::variant + */ + std::variant JVariant_NullType_NitroDescribeImageOptions::toCpp() const { + if (isInstanceOf(JVariant_NullType_NitroDescribeImageOptions_impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_NitroDescribeImageOptions_impl::Second::javaClassStatic())) { + // It's a `NitroDescribeImageOptions` + auto jniValue = static_cast(this)->getValue(); + return jniValue->toCpp(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroDescribeImageOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroDescribeImageOptions.hpp new file mode 100644 index 0000000..0048eb2 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroDescribeImageOptions.hpp @@ -0,0 +1,74 @@ +/// +/// JVariant_NullType_NitroDescribeImageOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include "NitroDescribeImageOptions.hpp" +#include +#include +#include "JNitroDescribeImageOptions.hpp" +#include +#include +#include "JVariant_NullType_String.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_NitroDescribeImageOptions". + */ + class JVariant_NullType_NitroDescribeImageOptions: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroDescribeImageOptions;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1(JNitroDescribeImageOptions::fromCpp(std::get<1>(variant))); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant toCpp() const; + }; + + namespace JVariant_NullType_NitroDescribeImageOptions_impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroDescribeImageOptions$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroDescribeImageOptions$Second;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_NitroDescribeImageOptions_impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroExtractOptions.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroExtractOptions.cpp new file mode 100644 index 0000000..2886c15 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroExtractOptions.cpp @@ -0,0 +1,26 @@ +/// +/// JVariant_NullType_NitroExtractOptions.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_NitroExtractOptions.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_NitroExtractOptions to std::variant + */ + std::variant JVariant_NullType_NitroExtractOptions::toCpp() const { + if (isInstanceOf(JVariant_NullType_NitroExtractOptions_impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_NitroExtractOptions_impl::Second::javaClassStatic())) { + // It's a `NitroExtractOptions` + auto jniValue = static_cast(this)->getValue(); + return jniValue->toCpp(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroExtractOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroExtractOptions.hpp new file mode 100644 index 0000000..45825c0 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroExtractOptions.hpp @@ -0,0 +1,75 @@ +/// +/// JVariant_NullType_NitroExtractOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include "NitroExtractOptions.hpp" +#include +#include +#include "JNitroExtractOptions.hpp" +#include +#include +#include +#include "JVariant_NullType_Array_String_.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_NitroExtractOptions". + */ + class JVariant_NullType_NitroExtractOptions: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroExtractOptions;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1(JNitroExtractOptions::fromCpp(std::get<1>(variant))); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant toCpp() const; + }; + + namespace JVariant_NullType_NitroExtractOptions_impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroExtractOptions$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroExtractOptions$Second;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_NitroExtractOptions_impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroSummarizeOptions.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroSummarizeOptions.cpp new file mode 100644 index 0000000..d5fd134 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroSummarizeOptions.cpp @@ -0,0 +1,26 @@ +/// +/// JVariant_NullType_NitroSummarizeOptions.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_NitroSummarizeOptions.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_NitroSummarizeOptions to std::variant + */ + std::variant JVariant_NullType_NitroSummarizeOptions::toCpp() const { + if (isInstanceOf(JVariant_NullType_NitroSummarizeOptions_impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_NitroSummarizeOptions_impl::Second::javaClassStatic())) { + // It's a `NitroSummarizeOptions` + auto jniValue = static_cast(this)->getValue(); + return jniValue->toCpp(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroSummarizeOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroSummarizeOptions.hpp new file mode 100644 index 0000000..22909fd --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_NitroSummarizeOptions.hpp @@ -0,0 +1,76 @@ +/// +/// JVariant_NullType_NitroSummarizeOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include "NitroSummarizeOptions.hpp" +#include +#include +#include "JNitroSummarizeOptions.hpp" +#include "NitroSummarizeInputType.hpp" +#include +#include "JNitroSummarizeInputType.hpp" +#include "NitroSummarizeOutputType.hpp" +#include "JNitroSummarizeOutputType.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_NitroSummarizeOptions". + */ + class JVariant_NullType_NitroSummarizeOptions: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroSummarizeOptions;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1(JNitroSummarizeOptions::fromCpp(std::get<1>(variant))); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant toCpp() const; + }; + + namespace JVariant_NullType_NitroSummarizeOptions_impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroSummarizeOptions$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_NitroSummarizeOptions$Second;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_NitroSummarizeOptions_impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_String.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_String.cpp new file mode 100644 index 0000000..f4d8c68 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_String.cpp @@ -0,0 +1,26 @@ +/// +/// JVariant_NullType_String.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "JVariant_NullType_String.hpp" + +namespace margelo::nitro::ondeviceai { + /** + * Converts JVariant_NullType_String to std::variant + */ + std::variant JVariant_NullType_String::toCpp() const { + if (isInstanceOf(JVariant_NullType_String_impl::First::javaClassStatic())) { + // It's a `nitro::NullType` + auto jniValue = static_cast(this)->getValue(); + return nitro::null; + } else if (isInstanceOf(JVariant_NullType_String_impl::Second::javaClassStatic())) { + // It's a `std::string` + auto jniValue = static_cast(this)->getValue(); + return jniValue->toStdString(); + } + throw std::invalid_argument("Variant is unknown Kotlin instance!"); + } +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_String.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_String.hpp new file mode 100644 index 0000000..cb4be2c --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/c++/JVariant_NullType_String.hpp @@ -0,0 +1,70 @@ +/// +/// JVariant_NullType_String.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include + +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_String". + */ + class JVariant_NullType_String: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_String;"; + + static jni::local_ref create_0(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + static jni::local_ref create_1(jni::alias_ref value) { + static const auto method = javaClassStatic()->getStaticMethod)>("create"); + return method(javaClassStatic(), value); + } + + static jni::local_ref fromCpp(const std::variant& variant) { + switch (variant.index()) { + case 0: return create_0(JNull::null()); + case 1: return create_1(jni::make_jstring(std::get<1>(variant))); + default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")"); + } + } + + [[nodiscard]] std::variant toCpp() const; + }; + + namespace JVariant_NullType_String_impl { + class First: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_String$First;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + + class Second: public jni::JavaClass { + public: + static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/ondeviceai/Variant_NullType_String$Second;"; + + [[nodiscard]] jni::local_ref getValue() const { + static const auto field = javaClassStatic()->getField("value"); + return getFieldValue(field); + } + }; + } // namespace JVariant_NullType_String_impl +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroChatStreamChunk.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroChatStreamChunk.kt new file mode 100644 index 0000000..e76d888 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroChatStreamChunk.kt @@ -0,0 +1,80 @@ +/// +/// Func_void_NitroChatStreamChunk.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.jni.HybridData +import com.facebook.proguard.annotations.DoNotStrip +import dalvik.annotation.optimization.FastNative + + +/** + * Represents the JavaScript callback `(chunk: struct) => void`. + * This can be either implemented in C++ (in which case it might be a callback coming from JS), + * or in Kotlin/Java (in which case it is a native callback). + */ +@DoNotStrip +@Keep +@Suppress("ClassName", "RedundantUnitReturnType") +fun interface Func_void_NitroChatStreamChunk: (NitroChatStreamChunk) -> Unit { + /** + * Call the given JS callback. + * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted. + */ + @DoNotStrip + @Keep + override fun invoke(chunk: NitroChatStreamChunk): Unit +} + +/** + * Represents the JavaScript callback `(chunk: struct) => void`. + * This is implemented in C++, via a `std::function<...>`. + * The callback might be coming from JS. + */ +@DoNotStrip +@Keep +@Suppress( + "KotlinJniMissingFunction", "unused", + "RedundantSuppression", "RedundantUnitReturnType", "FunctionName", + "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName", +) +class Func_void_NitroChatStreamChunk_cxx: Func_void_NitroChatStreamChunk { + @DoNotStrip + @Keep + private val mHybridData: HybridData + + @DoNotStrip + @Keep + private constructor(hybridData: HybridData) { + mHybridData = hybridData + } + + @DoNotStrip + @Keep + override fun invoke(chunk: NitroChatStreamChunk): Unit + = invoke_cxx(chunk) + + @FastNative + private external fun invoke_cxx(chunk: NitroChatStreamChunk): Unit +} + +/** + * Represents the JavaScript callback `(chunk: struct) => void`. + * This is implemented in Java/Kotlin, via a `(NitroChatStreamChunk) -> Unit`. + * The callback is always coming from native. + */ +@DoNotStrip +@Keep +@Suppress("ClassName", "RedundantUnitReturnType", "unused") +class Func_void_NitroChatStreamChunk_java(private val function: (NitroChatStreamChunk) -> Unit): Func_void_NitroChatStreamChunk { + @DoNotStrip + @Keep + override fun invoke(chunk: NitroChatStreamChunk): Unit { + return this.function(chunk) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroModelDownloadProgress.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroModelDownloadProgress.kt new file mode 100644 index 0000000..6c1316c --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroModelDownloadProgress.kt @@ -0,0 +1,80 @@ +/// +/// Func_void_NitroModelDownloadProgress.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.jni.HybridData +import com.facebook.proguard.annotations.DoNotStrip +import dalvik.annotation.optimization.FastNative + + +/** + * Represents the JavaScript callback `(progress: struct) => void`. + * This can be either implemented in C++ (in which case it might be a callback coming from JS), + * or in Kotlin/Java (in which case it is a native callback). + */ +@DoNotStrip +@Keep +@Suppress("ClassName", "RedundantUnitReturnType") +fun interface Func_void_NitroModelDownloadProgress: (NitroModelDownloadProgress) -> Unit { + /** + * Call the given JS callback. + * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted. + */ + @DoNotStrip + @Keep + override fun invoke(progress: NitroModelDownloadProgress): Unit +} + +/** + * Represents the JavaScript callback `(progress: struct) => void`. + * This is implemented in C++, via a `std::function<...>`. + * The callback might be coming from JS. + */ +@DoNotStrip +@Keep +@Suppress( + "KotlinJniMissingFunction", "unused", + "RedundantSuppression", "RedundantUnitReturnType", "FunctionName", + "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName", +) +class Func_void_NitroModelDownloadProgress_cxx: Func_void_NitroModelDownloadProgress { + @DoNotStrip + @Keep + private val mHybridData: HybridData + + @DoNotStrip + @Keep + private constructor(hybridData: HybridData) { + mHybridData = hybridData + } + + @DoNotStrip + @Keep + override fun invoke(progress: NitroModelDownloadProgress): Unit + = invoke_cxx(progress) + + @FastNative + private external fun invoke_cxx(progress: NitroModelDownloadProgress): Unit +} + +/** + * Represents the JavaScript callback `(progress: struct) => void`. + * This is implemented in Java/Kotlin, via a `(NitroModelDownloadProgress) -> Unit`. + * The callback is always coming from native. + */ +@DoNotStrip +@Keep +@Suppress("ClassName", "RedundantUnitReturnType", "unused") +class Func_void_NitroModelDownloadProgress_java(private val function: (NitroModelDownloadProgress) -> Unit): Func_void_NitroModelDownloadProgress { + @DoNotStrip + @Keep + override fun invoke(progress: NitroModelDownloadProgress): Unit { + return this.function(progress) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroTextStreamChunk.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroTextStreamChunk.kt new file mode 100644 index 0000000..ca30f00 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Func_void_NitroTextStreamChunk.kt @@ -0,0 +1,80 @@ +/// +/// Func_void_NitroTextStreamChunk.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.jni.HybridData +import com.facebook.proguard.annotations.DoNotStrip +import dalvik.annotation.optimization.FastNative + + +/** + * Represents the JavaScript callback `(chunk: struct) => void`. + * This can be either implemented in C++ (in which case it might be a callback coming from JS), + * or in Kotlin/Java (in which case it is a native callback). + */ +@DoNotStrip +@Keep +@Suppress("ClassName", "RedundantUnitReturnType") +fun interface Func_void_NitroTextStreamChunk: (NitroTextStreamChunk) -> Unit { + /** + * Call the given JS callback. + * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted. + */ + @DoNotStrip + @Keep + override fun invoke(chunk: NitroTextStreamChunk): Unit +} + +/** + * Represents the JavaScript callback `(chunk: struct) => void`. + * This is implemented in C++, via a `std::function<...>`. + * The callback might be coming from JS. + */ +@DoNotStrip +@Keep +@Suppress( + "KotlinJniMissingFunction", "unused", + "RedundantSuppression", "RedundantUnitReturnType", "FunctionName", + "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName", +) +class Func_void_NitroTextStreamChunk_cxx: Func_void_NitroTextStreamChunk { + @DoNotStrip + @Keep + private val mHybridData: HybridData + + @DoNotStrip + @Keep + private constructor(hybridData: HybridData) { + mHybridData = hybridData + } + + @DoNotStrip + @Keep + override fun invoke(chunk: NitroTextStreamChunk): Unit + = invoke_cxx(chunk) + + @FastNative + private external fun invoke_cxx(chunk: NitroTextStreamChunk): Unit +} + +/** + * Represents the JavaScript callback `(chunk: struct) => void`. + * This is implemented in Java/Kotlin, via a `(NitroTextStreamChunk) -> Unit`. + * The callback is always coming from native. + */ +@DoNotStrip +@Keep +@Suppress("ClassName", "RedundantUnitReturnType", "unused") +class Func_void_NitroTextStreamChunk_java(private val function: (NitroTextStreamChunk) -> Unit): Func_void_NitroTextStreamChunk { + @DoNotStrip + @Keep + override fun invoke(chunk: NitroTextStreamChunk): Unit { + return this.function(chunk) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/HybridOndeviceAiSpec.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/HybridOndeviceAiSpec.kt new file mode 100644 index 0000000..000b7da --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/HybridOndeviceAiSpec.kt @@ -0,0 +1,237 @@ +/// +/// HybridOndeviceAiSpec.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.jni.HybridData +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.Promise +import com.margelo.nitro.core.NullType +import com.margelo.nitro.core.HybridObject + +/** + * A Kotlin class representing the OndeviceAi HybridObject. + * Implement this abstract class to create Kotlin-based instances of OndeviceAi. + */ +@DoNotStrip +@Keep +@Suppress( + "KotlinJniMissingFunction", "unused", + "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet", + "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName" +) +abstract class HybridOndeviceAiSpec: HybridObject() { + @DoNotStrip + private var mHybridData: HybridData = initHybrid() + + init { + super.updateNative(mHybridData) + } + + override fun updateNative(hybridData: HybridData) { + mHybridData = hybridData + super.updateNative(hybridData) + } + + // Default implementation of `HybridObject.toString()` + override fun toString(): String { + return "[HybridObject OndeviceAi]" + } + + // Properties + + + // Methods + @DoNotStrip + @Keep + abstract fun initialize(): Promise + + @DoNotStrip + @Keep + abstract fun getDeviceCapability(): Promise + + @DoNotStrip + @Keep + abstract fun summarize(text: String, options: Variant_NullType_NitroSummarizeOptions?): Promise + + @DoNotStrip + @Keep + abstract fun classify(text: String, options: Variant_NullType_NitroClassifyOptions?): Promise + + @DoNotStrip + @Keep + abstract fun extract(text: String, options: Variant_NullType_NitroExtractOptions?): Promise + + @DoNotStrip + @Keep + abstract fun chat(message: String, options: Variant_NullType_NitroChatOptions?): Promise + + @DoNotStrip + @Keep + abstract fun translate(text: String, options: NitroTranslateOptions): Promise + + @DoNotStrip + @Keep + abstract fun rewrite(text: String, options: NitroRewriteOptions): Promise + + @DoNotStrip + @Keep + abstract fun proofread(text: String): Promise + + @DoNotStrip + @Keep + abstract fun chatStream(message: String, options: Variant_NullType_NitroChatOptions?): Promise + + abstract fun addChatStreamListener(listener: (chunk: NitroChatStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun addChatStreamListener_cxx(listener: Func_void_NitroChatStreamChunk): Unit { + val __result = addChatStreamListener(listener) + return __result + } + + abstract fun removeChatStreamListener(listener: (chunk: NitroChatStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun removeChatStreamListener_cxx(listener: Func_void_NitroChatStreamChunk): Unit { + val __result = removeChatStreamListener(listener) + return __result + } + + @DoNotStrip + @Keep + abstract fun summarizeStreaming(text: String, options: Variant_NullType_NitroSummarizeOptions?): Promise + + abstract fun addSummarizeStreamListener(listener: (chunk: NitroTextStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun addSummarizeStreamListener_cxx(listener: Func_void_NitroTextStreamChunk): Unit { + val __result = addSummarizeStreamListener(listener) + return __result + } + + abstract fun removeSummarizeStreamListener(listener: (chunk: NitroTextStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun removeSummarizeStreamListener_cxx(listener: Func_void_NitroTextStreamChunk): Unit { + val __result = removeSummarizeStreamListener(listener) + return __result + } + + @DoNotStrip + @Keep + abstract fun translateStreaming(text: String, options: NitroTranslateOptions): Promise + + abstract fun addTranslateStreamListener(listener: (chunk: NitroTextStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun addTranslateStreamListener_cxx(listener: Func_void_NitroTextStreamChunk): Unit { + val __result = addTranslateStreamListener(listener) + return __result + } + + abstract fun removeTranslateStreamListener(listener: (chunk: NitroTextStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun removeTranslateStreamListener_cxx(listener: Func_void_NitroTextStreamChunk): Unit { + val __result = removeTranslateStreamListener(listener) + return __result + } + + @DoNotStrip + @Keep + abstract fun rewriteStreaming(text: String, options: NitroRewriteOptions): Promise + + abstract fun addRewriteStreamListener(listener: (chunk: NitroTextStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun addRewriteStreamListener_cxx(listener: Func_void_NitroTextStreamChunk): Unit { + val __result = addRewriteStreamListener(listener) + return __result + } + + abstract fun removeRewriteStreamListener(listener: (chunk: NitroTextStreamChunk) -> Unit): Unit + + @DoNotStrip + @Keep + private fun removeRewriteStreamListener_cxx(listener: Func_void_NitroTextStreamChunk): Unit { + val __result = removeRewriteStreamListener(listener) + return __result + } + + @DoNotStrip + @Keep + abstract fun describeImage(imageUri: String, options: Variant_NullType_NitroDescribeImageOptions?): Promise + + @DoNotStrip + @Keep + abstract fun getAvailableModels(): Promise> + + @DoNotStrip + @Keep + abstract fun getDownloadedModels(): Promise> + + @DoNotStrip + @Keep + abstract fun getLoadedModel(): Promise + + @DoNotStrip + @Keep + abstract fun getCurrentEngine(): Promise + + @DoNotStrip + @Keep + abstract fun downloadModel(modelId: String): Promise + + abstract fun addModelDownloadProgressListener(listener: (progress: NitroModelDownloadProgress) -> Unit): Unit + + @DoNotStrip + @Keep + private fun addModelDownloadProgressListener_cxx(listener: Func_void_NitroModelDownloadProgress): Unit { + val __result = addModelDownloadProgressListener(listener) + return __result + } + + abstract fun removeModelDownloadProgressListener(listener: (progress: NitroModelDownloadProgress) -> Unit): Unit + + @DoNotStrip + @Keep + private fun removeModelDownloadProgressListener_cxx(listener: Func_void_NitroModelDownloadProgress): Unit { + val __result = removeModelDownloadProgressListener(listener) + return __result + } + + @DoNotStrip + @Keep + abstract fun loadModel(modelId: String): Promise + + @DoNotStrip + @Keep + abstract fun deleteModel(modelId: String): Promise + + @DoNotStrip + @Keep + abstract fun getPromptApiStatus(): Promise + + @DoNotStrip + @Keep + abstract fun downloadPromptApiModel(): Promise + + private external fun initHybrid(): HybridData + + companion object { + protected const val TAG = "HybridOndeviceAiSpec" + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatMessage.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatMessage.kt new file mode 100644 index 0000000..98e5f98 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatMessage.kt @@ -0,0 +1,41 @@ +/// +/// NitroChatMessage.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroChatMessage". + */ +@DoNotStrip +@Keep +data class NitroChatMessage( + @DoNotStrip + @Keep + val role: NitroChatMessageRole, + @DoNotStrip + @Keep + val content: String +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(role: NitroChatMessageRole, content: String): NitroChatMessage { + return NitroChatMessage(role, content) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatMessageRole.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatMessageRole.kt new file mode 100644 index 0000000..9a71327 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatMessageRole.kt @@ -0,0 +1,22 @@ +/// +/// NitroChatMessageRole.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "NitroChatMessageRole". + */ +@DoNotStrip +@Keep +enum class NitroChatMessageRole(@DoNotStrip @Keep val value: Int) { + USER(0), + ASSISTANT(1), + SYSTEM(2); +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatOptions.kt new file mode 100644 index 0000000..3ad3b3d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatOptions.kt @@ -0,0 +1,41 @@ +/// +/// NitroChatOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the JavaScript object/struct "NitroChatOptions". + */ +@DoNotStrip +@Keep +data class NitroChatOptions( + @DoNotStrip + @Keep + val systemPrompt: Variant_NullType_String?, + @DoNotStrip + @Keep + val history: Variant_NullType_Array_NitroChatMessage_? +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(systemPrompt: Variant_NullType_String?, history: Variant_NullType_Array_NitroChatMessage_?): NitroChatOptions { + return NitroChatOptions(systemPrompt, history) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatResult.kt new file mode 100644 index 0000000..46edd5a --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatResult.kt @@ -0,0 +1,44 @@ +/// +/// NitroChatResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroChatResult". + */ +@DoNotStrip +@Keep +data class NitroChatResult( + @DoNotStrip + @Keep + val message: String, + @DoNotStrip + @Keep + val conversationId: String, + @DoNotStrip + @Keep + val canContinue: Boolean +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(message: String, conversationId: String, canContinue: Boolean): NitroChatResult { + return NitroChatResult(message, conversationId, canContinue) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatStreamChunk.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatStreamChunk.kt new file mode 100644 index 0000000..3807996 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroChatStreamChunk.kt @@ -0,0 +1,44 @@ +/// +/// NitroChatStreamChunk.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroChatStreamChunk". + */ +@DoNotStrip +@Keep +data class NitroChatStreamChunk( + @DoNotStrip + @Keep + val delta: String, + @DoNotStrip + @Keep + val accumulated: String, + @DoNotStrip + @Keep + val isFinal: Boolean +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(delta: String, accumulated: String, isFinal: Boolean): NitroChatStreamChunk { + return NitroChatStreamChunk(delta, accumulated, isFinal) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassification.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassification.kt new file mode 100644 index 0000000..1e66f5f --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassification.kt @@ -0,0 +1,44 @@ +/// +/// NitroClassification.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroClassification". + */ +@DoNotStrip +@Keep +data class NitroClassification( + @DoNotStrip + @Keep + val label: String, + @DoNotStrip + @Keep + val score: Double, + @DoNotStrip + @Keep + val metadata: String +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(label: String, score: Double, metadata: String): NitroClassification { + return NitroClassification(label, score, metadata) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassifyOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassifyOptions.kt new file mode 100644 index 0000000..ca59296 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassifyOptions.kt @@ -0,0 +1,41 @@ +/// +/// NitroClassifyOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the JavaScript object/struct "NitroClassifyOptions". + */ +@DoNotStrip +@Keep +data class NitroClassifyOptions( + @DoNotStrip + @Keep + val categories: Variant_NullType_Array_String_?, + @DoNotStrip + @Keep + val maxResults: Variant_NullType_Double? +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(categories: Variant_NullType_Array_String_?, maxResults: Variant_NullType_Double?): NitroClassifyOptions { + return NitroClassifyOptions(categories, maxResults) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassifyResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassifyResult.kt new file mode 100644 index 0000000..f105696 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroClassifyResult.kt @@ -0,0 +1,44 @@ +/// +/// NitroClassifyResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroClassifyResult". + */ +@DoNotStrip +@Keep +data class NitroClassifyResult( + @DoNotStrip + @Keep + val classifications: Array, + @DoNotStrip + @Keep + val topLabel: String, + @DoNotStrip + @Keep + val topScore: Double +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(classifications: Array, topLabel: String, topScore: Double): NitroClassifyResult { + return NitroClassifyResult(classifications, topLabel, topScore) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDescribeImageOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDescribeImageOptions.kt new file mode 100644 index 0000000..ca6ed9d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDescribeImageOptions.kt @@ -0,0 +1,38 @@ +/// +/// NitroDescribeImageOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the JavaScript object/struct "NitroDescribeImageOptions". + */ +@DoNotStrip +@Keep +data class NitroDescribeImageOptions( + @DoNotStrip + @Keep + val prompt: Variant_NullType_String? +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(prompt: Variant_NullType_String?): NitroDescribeImageOptions { + return NitroDescribeImageOptions(prompt) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDescribeImageResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDescribeImageResult.kt new file mode 100644 index 0000000..ee496d0 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDescribeImageResult.kt @@ -0,0 +1,41 @@ +/// +/// NitroDescribeImageResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroDescribeImageResult". + */ +@DoNotStrip +@Keep +data class NitroDescribeImageResult( + @DoNotStrip + @Keep + val description: String, + @DoNotStrip + @Keep + val confidence: Double +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(description: String, confidence: Double): NitroDescribeImageResult { + return NitroDescribeImageResult(description, confidence) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDeviceCapability.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDeviceCapability.kt new file mode 100644 index 0000000..0b7cb9d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroDeviceCapability.kt @@ -0,0 +1,74 @@ +/// +/// NitroDeviceCapability.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroDeviceCapability". + */ +@DoNotStrip +@Keep +data class NitroDeviceCapability( + @DoNotStrip + @Keep + val isSupported: Boolean, + @DoNotStrip + @Keep + val isModelReady: Boolean, + @DoNotStrip + @Keep + val supportsAppleIntelligence: Boolean, + @DoNotStrip + @Keep + val platform: OndeviceAiPlatform, + @DoNotStrip + @Keep + val featureSummarize: Boolean, + @DoNotStrip + @Keep + val featureClassify: Boolean, + @DoNotStrip + @Keep + val featureExtract: Boolean, + @DoNotStrip + @Keep + val featureChat: Boolean, + @DoNotStrip + @Keep + val featureTranslate: Boolean, + @DoNotStrip + @Keep + val featureRewrite: Boolean, + @DoNotStrip + @Keep + val featureProofread: Boolean, + @DoNotStrip + @Keep + val availableMemoryMB: Double, + @DoNotStrip + @Keep + val isLowPowerMode: Boolean +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(isSupported: Boolean, isModelReady: Boolean, supportsAppleIntelligence: Boolean, platform: OndeviceAiPlatform, featureSummarize: Boolean, featureClassify: Boolean, featureExtract: Boolean, featureChat: Boolean, featureTranslate: Boolean, featureRewrite: Boolean, featureProofread: Boolean, availableMemoryMB: Double, isLowPowerMode: Boolean): NitroDeviceCapability { + return NitroDeviceCapability(isSupported, isModelReady, supportsAppleIntelligence, platform, featureSummarize, featureClassify, featureExtract, featureChat, featureTranslate, featureRewrite, featureProofread, availableMemoryMB, isLowPowerMode) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractEntity.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractEntity.kt new file mode 100644 index 0000000..50ac2a3 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractEntity.kt @@ -0,0 +1,50 @@ +/// +/// NitroExtractEntity.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroExtractEntity". + */ +@DoNotStrip +@Keep +data class NitroExtractEntity( + @DoNotStrip + @Keep + val type: String, + @DoNotStrip + @Keep + val value: String, + @DoNotStrip + @Keep + val confidence: Double, + @DoNotStrip + @Keep + val startPos: Double, + @DoNotStrip + @Keep + val endPos: Double +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(type: String, value: String, confidence: Double, startPos: Double, endPos: Double): NitroExtractEntity { + return NitroExtractEntity(type, value, confidence, startPos, endPos) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractOptions.kt new file mode 100644 index 0000000..5513287 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractOptions.kt @@ -0,0 +1,38 @@ +/// +/// NitroExtractOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the JavaScript object/struct "NitroExtractOptions". + */ +@DoNotStrip +@Keep +data class NitroExtractOptions( + @DoNotStrip + @Keep + val entityTypes: Variant_NullType_Array_String_? +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(entityTypes: Variant_NullType_Array_String_?): NitroExtractOptions { + return NitroExtractOptions(entityTypes) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractResult.kt new file mode 100644 index 0000000..504a2b4 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroExtractResult.kt @@ -0,0 +1,38 @@ +/// +/// NitroExtractResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroExtractResult". + */ +@DoNotStrip +@Keep +data class NitroExtractResult( + @DoNotStrip + @Keep + val entities: Array +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(entities: Array): NitroExtractResult { + return NitroExtractResult(entities) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroInferenceEngine.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroInferenceEngine.kt new file mode 100644 index 0000000..693c7d8 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroInferenceEngine.kt @@ -0,0 +1,25 @@ +/// +/// NitroInferenceEngine.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "NitroInferenceEngine". + */ +@DoNotStrip +@Keep +enum class NitroInferenceEngine(@DoNotStrip @Keep val value: Int) { + FOUNDATION_MODELS(0), + LLAMA_CPP(1), + MLX(2), + CORE_ML(3), + PROMPT_API(4), + NONE(5); +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelDownloadProgress.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelDownloadProgress.kt new file mode 100644 index 0000000..51a4510 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelDownloadProgress.kt @@ -0,0 +1,50 @@ +/// +/// NitroModelDownloadProgress.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroModelDownloadProgress". + */ +@DoNotStrip +@Keep +data class NitroModelDownloadProgress( + @DoNotStrip + @Keep + val modelId: String, + @DoNotStrip + @Keep + val bytesDownloaded: Double, + @DoNotStrip + @Keep + val totalBytes: Double, + @DoNotStrip + @Keep + val progress: Double, + @DoNotStrip + @Keep + val state: NitroModelDownloadState +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(modelId: String, bytesDownloaded: Double, totalBytes: Double, progress: Double, state: NitroModelDownloadState): NitroModelDownloadProgress { + return NitroModelDownloadProgress(modelId, bytesDownloaded, totalBytes, progress, state) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelDownloadState.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelDownloadState.kt new file mode 100644 index 0000000..3e82ece --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelDownloadState.kt @@ -0,0 +1,25 @@ +/// +/// NitroModelDownloadState.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "NitroModelDownloadState". + */ +@DoNotStrip +@Keep +enum class NitroModelDownloadState(@DoNotStrip @Keep val value: Int) { + PENDING(0), + DOWNLOADING(1), + VERIFYING(2), + COMPLETED(3), + FAILED(4), + CANCELLED(5); +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelInfo.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelInfo.kt new file mode 100644 index 0000000..c533d88 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroModelInfo.kt @@ -0,0 +1,59 @@ +/// +/// NitroModelInfo.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroModelInfo". + */ +@DoNotStrip +@Keep +data class NitroModelInfo( + @DoNotStrip + @Keep + val modelId: String, + @DoNotStrip + @Keep + val name: String, + @DoNotStrip + @Keep + val version: String, + @DoNotStrip + @Keep + val sizeMB: Double, + @DoNotStrip + @Keep + val quantization: String, + @DoNotStrip + @Keep + val contextLength: Double, + @DoNotStrip + @Keep + val minMemoryMB: Double, + @DoNotStrip + @Keep + val isMultimodal: Boolean +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(modelId: String, name: String, version: String, sizeMB: Double, quantization: String, contextLength: Double, minMemoryMB: Double, isMultimodal: Boolean): NitroModelInfo { + return NitroModelInfo(modelId, name, version, sizeMB, quantization, contextLength, minMemoryMB, isMultimodal) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroOndeviceAiOnLoad.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroOndeviceAiOnLoad.kt new file mode 100644 index 0000000..c7a64df --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroOndeviceAiOnLoad.kt @@ -0,0 +1,35 @@ +/// +/// NitroOndeviceAiOnLoad.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import android.util.Log + +internal class NitroOndeviceAiOnLoad { + companion object { + private const val TAG = "NitroOndeviceAiOnLoad" + private var didLoad = false + /** + * Initializes the native part of "NitroOndeviceAi". + * This method is idempotent and can be called more than once. + */ + @JvmStatic + fun initializeNative() { + if (didLoad) return + try { + Log.i(TAG, "Loading NitroOndeviceAi C++ library...") + System.loadLibrary("NitroOndeviceAi") + Log.i(TAG, "Successfully loaded NitroOndeviceAi C++ library!") + didLoad = true + } catch (e: Error) { + Log.e(TAG, "Failed to load NitroOndeviceAi C++ library! Is it properly installed and linked? " + + "Is the name correct? (see `CMakeLists.txt`, at `add_library(...)`)", e) + throw e + } + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroProofreadCorrection.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroProofreadCorrection.kt new file mode 100644 index 0000000..45ec654 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroProofreadCorrection.kt @@ -0,0 +1,53 @@ +/// +/// NitroProofreadCorrection.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroProofreadCorrection". + */ +@DoNotStrip +@Keep +data class NitroProofreadCorrection( + @DoNotStrip + @Keep + val original: String, + @DoNotStrip + @Keep + val corrected: String, + @DoNotStrip + @Keep + val type: String, + @DoNotStrip + @Keep + val confidence: Double, + @DoNotStrip + @Keep + val startPos: Double, + @DoNotStrip + @Keep + val endPos: Double +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(original: String, corrected: String, type: String, confidence: Double, startPos: Double, endPos: Double): NitroProofreadCorrection { + return NitroProofreadCorrection(original, corrected, type, confidence, startPos, endPos) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroProofreadResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroProofreadResult.kt new file mode 100644 index 0000000..912f36d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroProofreadResult.kt @@ -0,0 +1,44 @@ +/// +/// NitroProofreadResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroProofreadResult". + */ +@DoNotStrip +@Keep +data class NitroProofreadResult( + @DoNotStrip + @Keep + val correctedText: String, + @DoNotStrip + @Keep + val corrections: Array, + @DoNotStrip + @Keep + val hasCorrections: Boolean +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(correctedText: String, corrections: Array, hasCorrections: Boolean): NitroProofreadResult { + return NitroProofreadResult(correctedText, corrections, hasCorrections) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteOptions.kt new file mode 100644 index 0000000..5132966 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteOptions.kt @@ -0,0 +1,38 @@ +/// +/// NitroRewriteOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroRewriteOptions". + */ +@DoNotStrip +@Keep +data class NitroRewriteOptions( + @DoNotStrip + @Keep + val outputType: NitroRewriteOutputType +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(outputType: NitroRewriteOutputType): NitroRewriteOptions { + return NitroRewriteOptions(outputType) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteOutputType.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteOutputType.kt new file mode 100644 index 0000000..1983225 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteOutputType.kt @@ -0,0 +1,25 @@ +/// +/// NitroRewriteOutputType.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "NitroRewriteOutputType". + */ +@DoNotStrip +@Keep +enum class NitroRewriteOutputType(@DoNotStrip @Keep val value: Int) { + ELABORATE(0), + EMOJIFY(1), + SHORTEN(2), + FRIENDLY(3), + PROFESSIONAL(4), + REPHRASE(5); +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteResult.kt new file mode 100644 index 0000000..89e7e71 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroRewriteResult.kt @@ -0,0 +1,44 @@ +/// +/// NitroRewriteResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroRewriteResult". + */ +@DoNotStrip +@Keep +data class NitroRewriteResult( + @DoNotStrip + @Keep + val rewrittenText: String, + @DoNotStrip + @Keep + val style: String, + @DoNotStrip + @Keep + val confidence: Double +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(rewrittenText: String, style: String, confidence: Double): NitroRewriteResult { + return NitroRewriteResult(rewrittenText, style, confidence) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeInputType.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeInputType.kt new file mode 100644 index 0000000..83fc896 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeInputType.kt @@ -0,0 +1,21 @@ +/// +/// NitroSummarizeInputType.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "NitroSummarizeInputType". + */ +@DoNotStrip +@Keep +enum class NitroSummarizeInputType(@DoNotStrip @Keep val value: Int) { + ARTICLE(0), + CONVERSATION(1); +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeOptions.kt new file mode 100644 index 0000000..87ecb03 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeOptions.kt @@ -0,0 +1,41 @@ +/// +/// NitroSummarizeOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroSummarizeOptions". + */ +@DoNotStrip +@Keep +data class NitroSummarizeOptions( + @DoNotStrip + @Keep + val inputType: NitroSummarizeInputType?, + @DoNotStrip + @Keep + val outputType: NitroSummarizeOutputType? +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(inputType: NitroSummarizeInputType?, outputType: NitroSummarizeOutputType?): NitroSummarizeOptions { + return NitroSummarizeOptions(inputType, outputType) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeOutputType.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeOutputType.kt new file mode 100644 index 0000000..a4559ad --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeOutputType.kt @@ -0,0 +1,22 @@ +/// +/// NitroSummarizeOutputType.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "NitroSummarizeOutputType". + */ +@DoNotStrip +@Keep +enum class NitroSummarizeOutputType(@DoNotStrip @Keep val value: Int) { + ONE_BULLET(0), + TWO_BULLETS(1), + THREE_BULLETS(2); +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeResult.kt new file mode 100644 index 0000000..d372edc --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroSummarizeResult.kt @@ -0,0 +1,47 @@ +/// +/// NitroSummarizeResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroSummarizeResult". + */ +@DoNotStrip +@Keep +data class NitroSummarizeResult( + @DoNotStrip + @Keep + val summary: String, + @DoNotStrip + @Keep + val originalLength: Double, + @DoNotStrip + @Keep + val summaryLength: Double, + @DoNotStrip + @Keep + val confidence: Double +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(summary: String, originalLength: Double, summaryLength: Double, confidence: Double): NitroSummarizeResult { + return NitroSummarizeResult(summary, originalLength, summaryLength, confidence) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTextStreamChunk.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTextStreamChunk.kt new file mode 100644 index 0000000..06e04de --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTextStreamChunk.kt @@ -0,0 +1,44 @@ +/// +/// NitroTextStreamChunk.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroTextStreamChunk". + */ +@DoNotStrip +@Keep +data class NitroTextStreamChunk( + @DoNotStrip + @Keep + val delta: String, + @DoNotStrip + @Keep + val accumulated: String, + @DoNotStrip + @Keep + val isFinal: Boolean +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(delta: String, accumulated: String, isFinal: Boolean): NitroTextStreamChunk { + return NitroTextStreamChunk(delta, accumulated, isFinal) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTranslateOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTranslateOptions.kt new file mode 100644 index 0000000..4c19e04 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTranslateOptions.kt @@ -0,0 +1,41 @@ +/// +/// NitroTranslateOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroTranslateOptions". + */ +@DoNotStrip +@Keep +data class NitroTranslateOptions( + @DoNotStrip + @Keep + val sourceLanguage: String, + @DoNotStrip + @Keep + val targetLanguage: String +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(sourceLanguage: String, targetLanguage: String): NitroTranslateOptions { + return NitroTranslateOptions(sourceLanguage, targetLanguage) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTranslateResult.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTranslateResult.kt new file mode 100644 index 0000000..982048c --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/NitroTranslateResult.kt @@ -0,0 +1,47 @@ +/// +/// NitroTranslateResult.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + + +/** + * Represents the JavaScript object/struct "NitroTranslateResult". + */ +@DoNotStrip +@Keep +data class NitroTranslateResult( + @DoNotStrip + @Keep + val translatedText: String, + @DoNotStrip + @Keep + val sourceLanguage: String, + @DoNotStrip + @Keep + val targetLanguage: String, + @DoNotStrip + @Keep + val confidence: Double +) { + /* primary constructor */ + + private companion object { + /** + * Constructor called from C++ + */ + @DoNotStrip + @Keep + @Suppress("unused") + @JvmStatic + private fun fromCpp(translatedText: String, sourceLanguage: String, targetLanguage: String, confidence: Double): NitroTranslateResult { + return NitroTranslateResult(translatedText, sourceLanguage, targetLanguage, confidence) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/OndeviceAiPlatform.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/OndeviceAiPlatform.kt new file mode 100644 index 0000000..912fce9 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/OndeviceAiPlatform.kt @@ -0,0 +1,21 @@ +/// +/// OndeviceAiPlatform.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "OndeviceAiPlatform". + */ +@DoNotStrip +@Keep +enum class OndeviceAiPlatform(@DoNotStrip @Keep val value: Int) { + APPLE(0), + GOOGLE(1); +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Array_NitroChatMessage_.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Array_NitroChatMessage_.kt new file mode 100644 index 0000000..38d8166 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Array_NitroChatMessage_.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_Array_NitroChatMessage_.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | Array". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_Array_NitroChatMessage_ { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_Array_NitroChatMessage_() + @DoNotStrip + data class Second(@DoNotStrip val value: Array): Variant_NullType_Array_NitroChatMessage_() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): Array? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (Array) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_Array_NitroChatMessage_ = First(value) + @JvmStatic + @DoNotStrip + fun create(value: Array): Variant_NullType_Array_NitroChatMessage_ = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Array_String_.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Array_String_.kt new file mode 100644 index 0000000..edcb187 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Array_String_.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_Array_String_.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | Array". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_Array_String_ { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_Array_String_() + @DoNotStrip + data class Second(@DoNotStrip val value: Array): Variant_NullType_Array_String_() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): Array? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (Array) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_Array_String_ = First(value) + @JvmStatic + @DoNotStrip + fun create(value: Array): Variant_NullType_Array_String_ = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Double.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Double.kt new file mode 100644 index 0000000..e1ebca1 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_Double.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_Double.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | Double". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_Double { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_Double() + @DoNotStrip + data class Second(@DoNotStrip val value: Double): Variant_NullType_Double() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): Double? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (Double) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_Double = First(value) + @JvmStatic + @DoNotStrip + fun create(value: Double): Variant_NullType_Double = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroChatOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroChatOptions.kt new file mode 100644 index 0000000..54dd885 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroChatOptions.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_NitroChatOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | NitroChatOptions". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_NitroChatOptions { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_NitroChatOptions() + @DoNotStrip + data class Second(@DoNotStrip val value: NitroChatOptions): Variant_NullType_NitroChatOptions() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): NitroChatOptions? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (NitroChatOptions) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_NitroChatOptions = First(value) + @JvmStatic + @DoNotStrip + fun create(value: NitroChatOptions): Variant_NullType_NitroChatOptions = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroClassifyOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroClassifyOptions.kt new file mode 100644 index 0000000..ce9ed29 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroClassifyOptions.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_NitroClassifyOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | NitroClassifyOptions". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_NitroClassifyOptions { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_NitroClassifyOptions() + @DoNotStrip + data class Second(@DoNotStrip val value: NitroClassifyOptions): Variant_NullType_NitroClassifyOptions() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): NitroClassifyOptions? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (NitroClassifyOptions) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_NitroClassifyOptions = First(value) + @JvmStatic + @DoNotStrip + fun create(value: NitroClassifyOptions): Variant_NullType_NitroClassifyOptions = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroDescribeImageOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroDescribeImageOptions.kt new file mode 100644 index 0000000..aa7bddc --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroDescribeImageOptions.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_NitroDescribeImageOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | NitroDescribeImageOptions". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_NitroDescribeImageOptions { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_NitroDescribeImageOptions() + @DoNotStrip + data class Second(@DoNotStrip val value: NitroDescribeImageOptions): Variant_NullType_NitroDescribeImageOptions() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): NitroDescribeImageOptions? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (NitroDescribeImageOptions) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_NitroDescribeImageOptions = First(value) + @JvmStatic + @DoNotStrip + fun create(value: NitroDescribeImageOptions): Variant_NullType_NitroDescribeImageOptions = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroExtractOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroExtractOptions.kt new file mode 100644 index 0000000..735f717 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroExtractOptions.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_NitroExtractOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | NitroExtractOptions". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_NitroExtractOptions { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_NitroExtractOptions() + @DoNotStrip + data class Second(@DoNotStrip val value: NitroExtractOptions): Variant_NullType_NitroExtractOptions() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): NitroExtractOptions? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (NitroExtractOptions) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_NitroExtractOptions = First(value) + @JvmStatic + @DoNotStrip + fun create(value: NitroExtractOptions): Variant_NullType_NitroExtractOptions = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroSummarizeOptions.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroSummarizeOptions.kt new file mode 100644 index 0000000..b6ec791 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_NitroSummarizeOptions.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_NitroSummarizeOptions.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | NitroSummarizeOptions". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_NitroSummarizeOptions { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_NitroSummarizeOptions() + @DoNotStrip + data class Second(@DoNotStrip val value: NitroSummarizeOptions): Variant_NullType_NitroSummarizeOptions() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): NitroSummarizeOptions? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (NitroSummarizeOptions) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_NitroSummarizeOptions = First(value) + @JvmStatic + @DoNotStrip + fun create(value: NitroSummarizeOptions): Variant_NullType_NitroSummarizeOptions = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_String.kt b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_String.kt new file mode 100644 index 0000000..1fadd34 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/android/kotlin/com/margelo/nitro/ondeviceai/Variant_NullType_String.kt @@ -0,0 +1,59 @@ +/// +/// Variant_NullType_String.kt +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +package com.margelo.nitro.ondeviceai + +import com.facebook.proguard.annotations.DoNotStrip +import com.margelo.nitro.core.NullType + +/** + * Represents the TypeScript variant "NullType | String". + */ +@Suppress("ClassName") +@DoNotStrip +sealed class Variant_NullType_String { + @DoNotStrip + data class First(@DoNotStrip val value: NullType): Variant_NullType_String() + @DoNotStrip + data class Second(@DoNotStrip val value: String): Variant_NullType_String() + + @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR) + inline fun getAs(): T? = when (this) { + is First -> value as? T + is Second -> value as? T + } + + val isFirst: Boolean + get() = this is First + val isSecond: Boolean + get() = this is Second + + fun asFirstOrNull(): NullType? { + val value = (this as? First)?.value ?: return null + return value + } + fun asSecondOrNull(): String? { + val value = (this as? Second)?.value ?: return null + return value + } + + inline fun match(first: (NullType) -> R, second: (String) -> R): R { + return when (this) { + is First -> first(value) + is Second -> second(value) + } + } + + companion object { + @JvmStatic + @DoNotStrip + fun create(value: NullType): Variant_NullType_String = First(value) + @JvmStatic + @DoNotStrip + fun create(value: String): Variant_NullType_String = Second(value) + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi+autolinking.rb b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi+autolinking.rb new file mode 100644 index 0000000..65e4973 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi+autolinking.rb @@ -0,0 +1,60 @@ +# +# NitroOndeviceAi+autolinking.rb +# This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +# https://github.com/mrousavy/nitro +# Copyright © 2026 Marc Rousavy @ Margelo +# + +# This is a Ruby script that adds all files generated by Nitrogen +# to the given podspec. +# +# To use it, add this to your .podspec: +# ```ruby +# Pod::Spec.new do |spec| +# # ... +# +# # Add all files generated by Nitrogen +# load 'nitrogen/generated/ios/NitroOndeviceAi+autolinking.rb' +# add_nitrogen_files(spec) +# end +# ``` + +def add_nitrogen_files(spec) + Pod::UI.puts "[NitroModules] 🔥 NitroOndeviceAi is boosted by nitro!" + + spec.dependency "NitroModules" + + current_source_files = Array(spec.attributes_hash['source_files']) + spec.source_files = current_source_files + [ + # Generated cross-platform specs + "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}", + # Generated bridges for the cross-platform specs + "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}", + ] + + current_public_header_files = Array(spec.attributes_hash['public_header_files']) + spec.public_header_files = current_public_header_files + [ + # Generated specs + "nitrogen/generated/shared/**/*.{h,hpp}", + # Swift to C++ bridging helpers + "nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Bridge.hpp" + ] + + current_private_header_files = Array(spec.attributes_hash['private_header_files']) + spec.private_header_files = current_private_header_files + [ + # iOS specific specs + "nitrogen/generated/ios/c++/**/*.{h,hpp}", + # Views are framework-specific and should be private + "nitrogen/generated/shared/**/views/**/*" + ] + + current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {} + spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({ + # Use C++ 20 + "CLANG_CXX_LANGUAGE_STANDARD" => "c++20", + # Enables C++ <-> Swift interop (by default it's only C) + "SWIFT_OBJC_INTEROP_MODE" => "objcxx", + # Enables stricter modular headers + "DEFINES_MODULE" => "YES", + }) +end diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Bridge.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Bridge.cpp new file mode 100644 index 0000000..06d6d24 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Bridge.cpp @@ -0,0 +1,185 @@ +/// +/// NitroOndeviceAi-Swift-Cxx-Bridge.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "NitroOndeviceAi-Swift-Cxx-Bridge.hpp" + +// Include C++ implementation defined types +#include "HybridOndeviceAiSpecSwift.hpp" +#include "NitroOndeviceAi-Swift-Cxx-Umbrella.hpp" +#include + +namespace margelo::nitro::ondeviceai::bridge::swift { + + // pragma MARK: std::function + Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_bool::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void { + swiftClosure.call(error); + }; + } + + // pragma MARK: std::function + Func_void_NitroDeviceCapability create_Func_void_NitroDeviceCapability(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroDeviceCapability::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroDeviceCapability& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroSummarizeResult create_Func_void_NitroSummarizeResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroSummarizeResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroSummarizeResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroClassifyResult create_Func_void_NitroClassifyResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroClassifyResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroClassifyResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroExtractResult create_Func_void_NitroExtractResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroExtractResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroExtractResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroChatResult create_Func_void_NitroChatResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroChatResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroChatResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroTranslateResult create_Func_void_NitroTranslateResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroTranslateResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroTranslateResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroRewriteResult create_Func_void_NitroRewriteResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroRewriteResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroRewriteResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroProofreadResult create_Func_void_NitroProofreadResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroProofreadResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroProofreadResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroChatStreamChunk create_Func_void_NitroChatStreamChunk(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroChatStreamChunk::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroChatStreamChunk& chunk) mutable -> void { + swiftClosure.call(chunk); + }; + } + + // pragma MARK: std::function + Func_void_NitroTextStreamChunk create_Func_void_NitroTextStreamChunk(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroTextStreamChunk::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroTextStreamChunk& chunk) mutable -> void { + swiftClosure.call(chunk); + }; + } + + // pragma MARK: std::function + Func_void_NitroDescribeImageResult create_Func_void_NitroDescribeImageResult(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroDescribeImageResult::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroDescribeImageResult& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function& /* result */)> + Func_void_std__vector_NitroModelInfo_ create_Func_void_std__vector_NitroModelInfo_(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_std__vector_NitroModelInfo_::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const std::vector& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function& /* result */)> + Func_void_std__vector_std__string_ create_Func_void_std__vector_std__string_(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_std__vector_std__string_::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const std::vector& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_std__string::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const std::string& result) mutable -> void { + swiftClosure.call(result); + }; + } + + // pragma MARK: std::function + Func_void_NitroInferenceEngine create_Func_void_NitroInferenceEngine(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroInferenceEngine::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](NitroInferenceEngine result) mutable -> void { + swiftClosure.call(static_cast(result)); + }; + } + + // pragma MARK: std::function + Func_void_NitroModelDownloadProgress create_Func_void_NitroModelDownloadProgress(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void_NitroModelDownloadProgress::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)](const NitroModelDownloadProgress& progress) mutable -> void { + swiftClosure.call(progress); + }; + } + + // pragma MARK: std::function + Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept { + auto swiftClosure = NitroOndeviceAi::Func_void::fromUnsafe(swiftClosureWrapper); + return [swiftClosure = std::move(swiftClosure)]() mutable -> void { + swiftClosure.call(); + }; + } + + // pragma MARK: std::shared_ptr + std::shared_ptr create_std__shared_ptr_HybridOndeviceAiSpec_(void* NON_NULL swiftUnsafePointer) noexcept { + NitroOndeviceAi::HybridOndeviceAiSpec_cxx swiftPart = NitroOndeviceAi::HybridOndeviceAiSpec_cxx::fromUnsafe(swiftUnsafePointer); + return std::make_shared(swiftPart); + } + void* NON_NULL get_std__shared_ptr_HybridOndeviceAiSpec_(std__shared_ptr_HybridOndeviceAiSpec_ cppType) { + std::shared_ptr swiftWrapper = std::dynamic_pointer_cast(cppType); + #ifdef NITRO_DEBUG + if (swiftWrapper == nullptr) [[unlikely]] { + throw std::runtime_error("Class \"HybridOndeviceAiSpec\" is not implemented in Swift!"); + } + #endif + NitroOndeviceAi::HybridOndeviceAiSpec_cxx& swiftPart = swiftWrapper->getSwiftPart(); + return swiftPart.toUnsafe(); + } + +} // namespace margelo::nitro::ondeviceai::bridge::swift diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Bridge.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Bridge.hpp new file mode 100644 index 0000000..6961454 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Bridge.hpp @@ -0,0 +1,1368 @@ +/// +/// NitroOndeviceAi-Swift-Cxx-Bridge.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +// Forward declarations of C++ defined types +// Forward declaration of `HybridOndeviceAiSpec` to properly resolve imports. +namespace margelo::nitro::ondeviceai { class HybridOndeviceAiSpec; } +// Forward declaration of `NitroChatMessageRole` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroChatMessageRole; } +// Forward declaration of `NitroChatMessage` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatMessage; } +// Forward declaration of `NitroChatOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatOptions; } +// Forward declaration of `NitroChatResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatResult; } +// Forward declaration of `NitroChatStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatStreamChunk; } +// Forward declaration of `NitroClassification` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassification; } +// Forward declaration of `NitroClassifyOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyOptions; } +// Forward declaration of `NitroClassifyResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyResult; } +// Forward declaration of `NitroDescribeImageOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageOptions; } +// Forward declaration of `NitroDescribeImageResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageResult; } +// Forward declaration of `NitroDeviceCapability` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDeviceCapability; } +// Forward declaration of `NitroExtractEntity` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractEntity; } +// Forward declaration of `NitroExtractOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractOptions; } +// Forward declaration of `NitroExtractResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractResult; } +// Forward declaration of `NitroInferenceEngine` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroInferenceEngine; } +// Forward declaration of `NitroModelDownloadProgress` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelDownloadProgress; } +// Forward declaration of `NitroModelDownloadState` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroModelDownloadState; } +// Forward declaration of `NitroModelInfo` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelInfo; } +// Forward declaration of `NitroProofreadCorrection` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadCorrection; } +// Forward declaration of `NitroProofreadResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadResult; } +// Forward declaration of `NitroRewriteResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteResult; } +// Forward declaration of `NitroSummarizeInputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeInputType; } +// Forward declaration of `NitroSummarizeOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeOptions; } +// Forward declaration of `NitroSummarizeOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeOutputType; } +// Forward declaration of `NitroSummarizeResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeResult; } +// Forward declaration of `NitroTextStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTextStreamChunk; } +// Forward declaration of `NitroTranslateResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateResult; } +// Forward declaration of `OndeviceAiPlatform` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class OndeviceAiPlatform; } + +// Forward declarations of Swift defined types +// Forward declaration of `HybridOndeviceAiSpec_cxx` to properly resolve imports. +namespace NitroOndeviceAi { class HybridOndeviceAiSpec_cxx; } + +// Include C++ defined types +#include "HybridOndeviceAiSpec.hpp" +#include "NitroChatMessage.hpp" +#include "NitroChatMessageRole.hpp" +#include "NitroChatOptions.hpp" +#include "NitroChatResult.hpp" +#include "NitroChatStreamChunk.hpp" +#include "NitroClassification.hpp" +#include "NitroClassifyOptions.hpp" +#include "NitroClassifyResult.hpp" +#include "NitroDescribeImageOptions.hpp" +#include "NitroDescribeImageResult.hpp" +#include "NitroDeviceCapability.hpp" +#include "NitroExtractEntity.hpp" +#include "NitroExtractOptions.hpp" +#include "NitroExtractResult.hpp" +#include "NitroInferenceEngine.hpp" +#include "NitroModelDownloadProgress.hpp" +#include "NitroModelDownloadState.hpp" +#include "NitroModelInfo.hpp" +#include "NitroProofreadCorrection.hpp" +#include "NitroProofreadResult.hpp" +#include "NitroRewriteResult.hpp" +#include "NitroSummarizeInputType.hpp" +#include "NitroSummarizeOptions.hpp" +#include "NitroSummarizeOutputType.hpp" +#include "NitroSummarizeResult.hpp" +#include "NitroTextStreamChunk.hpp" +#include "NitroTranslateResult.hpp" +#include "OndeviceAiPlatform.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * Contains specialized versions of C++ templated types so they can be accessed from Swift, + * as well as helper functions to interact with those C++ types from Swift. + */ +namespace margelo::nitro::ondeviceai::bridge::swift { + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_bool__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_bool__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_bool__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_bool = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_bool_Wrapper final { + public: + explicit Func_void_bool_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(bool result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept { + return Func_void_bool_Wrapper(std::move(value)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_std__exception_ptr = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_std__exception_ptr_Wrapper final { + public: + explicit Func_void_std__exception_ptr_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(std::exception_ptr error) const noexcept { + _function->operator()(error); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept { + return Func_void_std__exception_ptr_Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroDeviceCapability__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroDeviceCapability__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroDeviceCapability__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroDeviceCapability = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroDeviceCapability_Wrapper final { + public: + explicit Func_void_NitroDeviceCapability_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroDeviceCapability result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroDeviceCapability create_Func_void_NitroDeviceCapability(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroDeviceCapability_Wrapper wrap_Func_void_NitroDeviceCapability(Func_void_NitroDeviceCapability value) noexcept { + return Func_void_NitroDeviceCapability_Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroSummarizeResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroSummarizeResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroSummarizeResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroSummarizeResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroSummarizeResult_Wrapper final { + public: + explicit Func_void_NitroSummarizeResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroSummarizeResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroSummarizeResult create_Func_void_NitroSummarizeResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroSummarizeResult_Wrapper wrap_Func_void_NitroSummarizeResult(Func_void_NitroSummarizeResult value) noexcept { + return Func_void_NitroSummarizeResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::optional + /** + * Specialized version of `std::optional`. + */ + using std__optional_NitroSummarizeInputType_ = std::optional; + inline std::optional create_std__optional_NitroSummarizeInputType_(const NitroSummarizeInputType& value) noexcept { + return std::optional(value); + } + inline bool has_value_std__optional_NitroSummarizeInputType_(const std::optional& optional) noexcept { + return optional.has_value(); + } + inline NitroSummarizeInputType get_std__optional_NitroSummarizeInputType_(const std::optional& optional) noexcept { + return *optional; + } + + // pragma MARK: std::optional + /** + * Specialized version of `std::optional`. + */ + using std__optional_NitroSummarizeOutputType_ = std::optional; + inline std::optional create_std__optional_NitroSummarizeOutputType_(const NitroSummarizeOutputType& value) noexcept { + return std::optional(value); + } + inline bool has_value_std__optional_NitroSummarizeOutputType_(const std::optional& optional) noexcept { + return optional.has_value(); + } + inline NitroSummarizeOutputType get_std__optional_NitroSummarizeOutputType_(const std::optional& optional) noexcept { + return *optional; + } + + // pragma MARK: std::variant + /** + * Wrapper struct for `std::variant`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__NitroSummarizeOptions_ { + std::variant variant; + std__variant_nitro__NullType__NitroSummarizeOptions_(std::variant variant): variant(variant) { } + operator std::variant() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline NitroSummarizeOptions get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__NitroSummarizeOptions_ create_std__variant_nitro__NullType__NitroSummarizeOptions_(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__NitroSummarizeOptions_(value); + } + inline std__variant_nitro__NullType__NitroSummarizeOptions_ create_std__variant_nitro__NullType__NitroSummarizeOptions_(const NitroSummarizeOptions& value) noexcept { + return std__variant_nitro__NullType__NitroSummarizeOptions_(value); + } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__ = std::optional>; + inline std::optional> create_std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__(const std::variant& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::variant get_std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__(const std::optional>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::vector + /** + * Specialized version of `std::vector`. + */ + using std__vector_NitroClassification_ = std::vector; + inline std::vector create_std__vector_NitroClassification_(size_t size) noexcept { + std::vector vector; + vector.reserve(size); + return vector; + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroClassifyResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroClassifyResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroClassifyResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroClassifyResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroClassifyResult_Wrapper final { + public: + explicit Func_void_NitroClassifyResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroClassifyResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroClassifyResult create_Func_void_NitroClassifyResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroClassifyResult_Wrapper wrap_Func_void_NitroClassifyResult(Func_void_NitroClassifyResult value) noexcept { + return Func_void_NitroClassifyResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::vector + /** + * Specialized version of `std::vector`. + */ + using std__vector_std__string_ = std::vector; + inline std::vector create_std__vector_std__string_(size_t size) noexcept { + std::vector vector; + vector.reserve(size); + return vector; + } + + // pragma MARK: std::variant> + /** + * Wrapper struct for `std::variant>`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__std__vector_std__string__ { + std::variant> variant; + std__variant_nitro__NullType__std__vector_std__string__(std::variant> variant): variant(variant) { } + operator std::variant>() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline std::vector get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__std__vector_std__string__ create_std__variant_nitro__NullType__std__vector_std__string__(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__std__vector_std__string__(value); + } + inline std__variant_nitro__NullType__std__vector_std__string__ create_std__variant_nitro__NullType__std__vector_std__string__(const std::vector& value) noexcept { + return std__variant_nitro__NullType__std__vector_std__string__(value); + } + + // pragma MARK: std::optional>> + /** + * Specialized version of `std::optional>>`. + */ + using std__optional_std__variant_nitro__NullType__std__vector_std__string___ = std::optional>>; + inline std::optional>> create_std__optional_std__variant_nitro__NullType__std__vector_std__string___(const std::variant>& value) noexcept { + return std::optional>>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_std__string___(const std::optional>>& optional) noexcept { + return optional.has_value(); + } + inline std::variant> get_std__optional_std__variant_nitro__NullType__std__vector_std__string___(const std::optional>>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::variant + /** + * Wrapper struct for `std::variant`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__double_ { + std::variant variant; + std__variant_nitro__NullType__double_(std::variant variant): variant(variant) { } + operator std::variant() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline double get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__double_(value); + } + inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(double value) noexcept { + return std__variant_nitro__NullType__double_(value); + } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__variant_nitro__NullType__double__ = std::optional>; + inline std::optional> create_std__optional_std__variant_nitro__NullType__double__(const std::variant& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::variant get_std__optional_std__variant_nitro__NullType__double__(const std::optional>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::variant + /** + * Wrapper struct for `std::variant`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__NitroClassifyOptions_ { + std::variant variant; + std__variant_nitro__NullType__NitroClassifyOptions_(std::variant variant): variant(variant) { } + operator std::variant() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline NitroClassifyOptions get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__NitroClassifyOptions_ create_std__variant_nitro__NullType__NitroClassifyOptions_(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__NitroClassifyOptions_(value); + } + inline std__variant_nitro__NullType__NitroClassifyOptions_ create_std__variant_nitro__NullType__NitroClassifyOptions_(const NitroClassifyOptions& value) noexcept { + return std__variant_nitro__NullType__NitroClassifyOptions_(value); + } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__variant_nitro__NullType__NitroClassifyOptions__ = std::optional>; + inline std::optional> create_std__optional_std__variant_nitro__NullType__NitroClassifyOptions__(const std::variant& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__NitroClassifyOptions__(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::variant get_std__optional_std__variant_nitro__NullType__NitroClassifyOptions__(const std::optional>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::vector + /** + * Specialized version of `std::vector`. + */ + using std__vector_NitroExtractEntity_ = std::vector; + inline std::vector create_std__vector_NitroExtractEntity_(size_t size) noexcept { + std::vector vector; + vector.reserve(size); + return vector; + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroExtractResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroExtractResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroExtractResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroExtractResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroExtractResult_Wrapper final { + public: + explicit Func_void_NitroExtractResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroExtractResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroExtractResult create_Func_void_NitroExtractResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroExtractResult_Wrapper wrap_Func_void_NitroExtractResult(Func_void_NitroExtractResult value) noexcept { + return Func_void_NitroExtractResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::variant + /** + * Wrapper struct for `std::variant`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__NitroExtractOptions_ { + std::variant variant; + std__variant_nitro__NullType__NitroExtractOptions_(std::variant variant): variant(variant) { } + operator std::variant() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline NitroExtractOptions get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__NitroExtractOptions_ create_std__variant_nitro__NullType__NitroExtractOptions_(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__NitroExtractOptions_(value); + } + inline std__variant_nitro__NullType__NitroExtractOptions_ create_std__variant_nitro__NullType__NitroExtractOptions_(const NitroExtractOptions& value) noexcept { + return std__variant_nitro__NullType__NitroExtractOptions_(value); + } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__variant_nitro__NullType__NitroExtractOptions__ = std::optional>; + inline std::optional> create_std__optional_std__variant_nitro__NullType__NitroExtractOptions__(const std::variant& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__NitroExtractOptions__(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::variant get_std__optional_std__variant_nitro__NullType__NitroExtractOptions__(const std::optional>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroChatResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroChatResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroChatResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroChatResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroChatResult_Wrapper final { + public: + explicit Func_void_NitroChatResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroChatResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroChatResult create_Func_void_NitroChatResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroChatResult_Wrapper wrap_Func_void_NitroChatResult(Func_void_NitroChatResult value) noexcept { + return Func_void_NitroChatResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::variant + /** + * Wrapper struct for `std::variant`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__std__string_ { + std::variant variant; + std__variant_nitro__NullType__std__string_(std::variant variant): variant(variant) { } + operator std::variant() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline std::string get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__std__string_(value); + } + inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(const std::string& value) noexcept { + return std__variant_nitro__NullType__std__string_(value); + } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__variant_nitro__NullType__std__string__ = std::optional>; + inline std::optional> create_std__optional_std__variant_nitro__NullType__std__string__(const std::variant& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__std__string__(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::variant get_std__optional_std__variant_nitro__NullType__std__string__(const std::optional>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::vector + /** + * Specialized version of `std::vector`. + */ + using std__vector_NitroChatMessage_ = std::vector; + inline std::vector create_std__vector_NitroChatMessage_(size_t size) noexcept { + std::vector vector; + vector.reserve(size); + return vector; + } + + // pragma MARK: std::variant> + /** + * Wrapper struct for `std::variant>`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__std__vector_NitroChatMessage__ { + std::variant> variant; + std__variant_nitro__NullType__std__vector_NitroChatMessage__(std::variant> variant): variant(variant) { } + operator std::variant>() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline std::vector get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__std__vector_NitroChatMessage__ create_std__variant_nitro__NullType__std__vector_NitroChatMessage__(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__std__vector_NitroChatMessage__(value); + } + inline std__variant_nitro__NullType__std__vector_NitroChatMessage__ create_std__variant_nitro__NullType__std__vector_NitroChatMessage__(const std::vector& value) noexcept { + return std__variant_nitro__NullType__std__vector_NitroChatMessage__(value); + } + + // pragma MARK: std::optional>> + /** + * Specialized version of `std::optional>>`. + */ + using std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___ = std::optional>>; + inline std::optional>> create_std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___(const std::variant>& value) noexcept { + return std::optional>>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___(const std::optional>>& optional) noexcept { + return optional.has_value(); + } + inline std::variant> get_std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___(const std::optional>>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::variant + /** + * Wrapper struct for `std::variant`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__NitroChatOptions_ { + std::variant variant; + std__variant_nitro__NullType__NitroChatOptions_(std::variant variant): variant(variant) { } + operator std::variant() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline NitroChatOptions get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__NitroChatOptions_ create_std__variant_nitro__NullType__NitroChatOptions_(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__NitroChatOptions_(value); + } + inline std__variant_nitro__NullType__NitroChatOptions_ create_std__variant_nitro__NullType__NitroChatOptions_(const NitroChatOptions& value) noexcept { + return std__variant_nitro__NullType__NitroChatOptions_(value); + } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__variant_nitro__NullType__NitroChatOptions__ = std::optional>; + inline std::optional> create_std__optional_std__variant_nitro__NullType__NitroChatOptions__(const std::variant& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__NitroChatOptions__(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::variant get_std__optional_std__variant_nitro__NullType__NitroChatOptions__(const std::optional>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroTranslateResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroTranslateResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroTranslateResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroTranslateResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroTranslateResult_Wrapper final { + public: + explicit Func_void_NitroTranslateResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroTranslateResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroTranslateResult create_Func_void_NitroTranslateResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroTranslateResult_Wrapper wrap_Func_void_NitroTranslateResult(Func_void_NitroTranslateResult value) noexcept { + return Func_void_NitroTranslateResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroRewriteResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroRewriteResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroRewriteResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroRewriteResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroRewriteResult_Wrapper final { + public: + explicit Func_void_NitroRewriteResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroRewriteResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroRewriteResult create_Func_void_NitroRewriteResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroRewriteResult_Wrapper wrap_Func_void_NitroRewriteResult(Func_void_NitroRewriteResult value) noexcept { + return Func_void_NitroRewriteResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::vector + /** + * Specialized version of `std::vector`. + */ + using std__vector_NitroProofreadCorrection_ = std::vector; + inline std::vector create_std__vector_NitroProofreadCorrection_(size_t size) noexcept { + std::vector vector; + vector.reserve(size); + return vector; + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroProofreadResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroProofreadResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroProofreadResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroProofreadResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroProofreadResult_Wrapper final { + public: + explicit Func_void_NitroProofreadResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroProofreadResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroProofreadResult create_Func_void_NitroProofreadResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroProofreadResult_Wrapper wrap_Func_void_NitroProofreadResult(Func_void_NitroProofreadResult value) noexcept { + return Func_void_NitroProofreadResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroChatStreamChunk = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroChatStreamChunk_Wrapper final { + public: + explicit Func_void_NitroChatStreamChunk_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroChatStreamChunk chunk) const noexcept { + _function->operator()(chunk); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroChatStreamChunk create_Func_void_NitroChatStreamChunk(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroChatStreamChunk_Wrapper wrap_Func_void_NitroChatStreamChunk(Func_void_NitroChatStreamChunk value) noexcept { + return Func_void_NitroChatStreamChunk_Wrapper(std::move(value)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroTextStreamChunk = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroTextStreamChunk_Wrapper final { + public: + explicit Func_void_NitroTextStreamChunk_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroTextStreamChunk chunk) const noexcept { + _function->operator()(chunk); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroTextStreamChunk create_Func_void_NitroTextStreamChunk(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroTextStreamChunk_Wrapper wrap_Func_void_NitroTextStreamChunk(Func_void_NitroTextStreamChunk value) noexcept { + return Func_void_NitroTextStreamChunk_Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroDescribeImageResult__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroDescribeImageResult__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroDescribeImageResult__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroDescribeImageResult = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroDescribeImageResult_Wrapper final { + public: + explicit Func_void_NitroDescribeImageResult_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroDescribeImageResult result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroDescribeImageResult create_Func_void_NitroDescribeImageResult(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroDescribeImageResult_Wrapper wrap_Func_void_NitroDescribeImageResult(Func_void_NitroDescribeImageResult value) noexcept { + return Func_void_NitroDescribeImageResult_Wrapper(std::move(value)); + } + + // pragma MARK: std::variant + /** + * Wrapper struct for `std::variant`. + * std::variant cannot be used in Swift because of a Swift bug. + * Not even specializing it works. So we create a wrapper struct. + */ + struct std__variant_nitro__NullType__NitroDescribeImageOptions_ { + std::variant variant; + std__variant_nitro__NullType__NitroDescribeImageOptions_(std::variant variant): variant(variant) { } + operator std::variant() const noexcept { + return variant; + } + inline size_t index() const noexcept { + return variant.index(); + } + inline nitro::NullType get_0() const noexcept { + return std::get<0>(variant); + } + inline NitroDescribeImageOptions get_1() const noexcept { + return std::get<1>(variant); + } + }; + inline std__variant_nitro__NullType__NitroDescribeImageOptions_ create_std__variant_nitro__NullType__NitroDescribeImageOptions_(nitro::NullType value) noexcept { + return std__variant_nitro__NullType__NitroDescribeImageOptions_(value); + } + inline std__variant_nitro__NullType__NitroDescribeImageOptions_ create_std__variant_nitro__NullType__NitroDescribeImageOptions_(const NitroDescribeImageOptions& value) noexcept { + return std__variant_nitro__NullType__NitroDescribeImageOptions_(value); + } + + // pragma MARK: std::optional> + /** + * Specialized version of `std::optional>`. + */ + using std__optional_std__variant_nitro__NullType__NitroDescribeImageOptions__ = std::optional>; + inline std::optional> create_std__optional_std__variant_nitro__NullType__NitroDescribeImageOptions__(const std::variant& value) noexcept { + return std::optional>(value); + } + inline bool has_value_std__optional_std__variant_nitro__NullType__NitroDescribeImageOptions__(const std::optional>& optional) noexcept { + return optional.has_value(); + } + inline std::variant get_std__optional_std__variant_nitro__NullType__NitroDescribeImageOptions__(const std::optional>& optional) noexcept { + return *optional; + } + + // pragma MARK: std::vector + /** + * Specialized version of `std::vector`. + */ + using std__vector_NitroModelInfo_ = std::vector; + inline std::vector create_std__vector_NitroModelInfo_(size_t size) noexcept { + std::vector vector; + vector.reserve(size); + return vector; + } + + // pragma MARK: std::shared_ptr>> + /** + * Specialized version of `std::shared_ptr>>`. + */ + using std__shared_ptr_Promise_std__vector_NitroModelInfo___ = std::shared_ptr>>; + inline std::shared_ptr>> create_std__shared_ptr_Promise_std__vector_NitroModelInfo___() noexcept { + return Promise>::create(); + } + inline PromiseHolder> wrap_std__shared_ptr_Promise_std__vector_NitroModelInfo___(std::shared_ptr>> promise) noexcept { + return PromiseHolder>(std::move(promise)); + } + + // pragma MARK: std::function& /* result */)> + /** + * Specialized version of `std::function&)>`. + */ + using Func_void_std__vector_NitroModelInfo_ = std::function& /* result */)>; + /** + * Wrapper class for a `std::function& / * result * /)>`, this can be used from Swift. + */ + class Func_void_std__vector_NitroModelInfo__Wrapper final { + public: + explicit Func_void_std__vector_NitroModelInfo__Wrapper(std::function& /* result */)>&& func): _function(std::make_unique& /* result */)>>(std::move(func))) {} + inline void call(std::vector result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr& /* result */)>> _function; + } SWIFT_NONCOPYABLE; + Func_void_std__vector_NitroModelInfo_ create_Func_void_std__vector_NitroModelInfo_(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_std__vector_NitroModelInfo__Wrapper wrap_Func_void_std__vector_NitroModelInfo_(Func_void_std__vector_NitroModelInfo_ value) noexcept { + return Func_void_std__vector_NitroModelInfo__Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr>> + /** + * Specialized version of `std::shared_ptr>>`. + */ + using std__shared_ptr_Promise_std__vector_std__string___ = std::shared_ptr>>; + inline std::shared_ptr>> create_std__shared_ptr_Promise_std__vector_std__string___() noexcept { + return Promise>::create(); + } + inline PromiseHolder> wrap_std__shared_ptr_Promise_std__vector_std__string___(std::shared_ptr>> promise) noexcept { + return PromiseHolder>(std::move(promise)); + } + + // pragma MARK: std::function& /* result */)> + /** + * Specialized version of `std::function&)>`. + */ + using Func_void_std__vector_std__string_ = std::function& /* result */)>; + /** + * Wrapper class for a `std::function& / * result * /)>`, this can be used from Swift. + */ + class Func_void_std__vector_std__string__Wrapper final { + public: + explicit Func_void_std__vector_std__string__Wrapper(std::function& /* result */)>&& func): _function(std::make_unique& /* result */)>>(std::move(func))) {} + inline void call(std::vector result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr& /* result */)>> _function; + } SWIFT_NONCOPYABLE; + Func_void_std__vector_std__string_ create_Func_void_std__vector_std__string_(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_std__vector_std__string__Wrapper wrap_Func_void_std__vector_std__string_(Func_void_std__vector_std__string_ value) noexcept { + return Func_void_std__vector_std__string__Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_std__string__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_std__string__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_std__string = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_std__string_Wrapper final { + public: + explicit Func_void_std__string_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(std::string result) const noexcept { + _function->operator()(result); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept { + return Func_void_std__string_Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_NitroInferenceEngine__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_NitroInferenceEngine__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_NitroInferenceEngine__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroInferenceEngine = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroInferenceEngine_Wrapper final { + public: + explicit Func_void_NitroInferenceEngine_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(int result) const noexcept { + _function->operator()(static_cast(result)); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroInferenceEngine create_Func_void_NitroInferenceEngine(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroInferenceEngine_Wrapper wrap_Func_void_NitroInferenceEngine(Func_void_NitroInferenceEngine value) noexcept { + return Func_void_NitroInferenceEngine_Wrapper(std::move(value)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void_NitroModelDownloadProgress = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_NitroModelDownloadProgress_Wrapper final { + public: + explicit Func_void_NitroModelDownloadProgress_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call(NitroModelDownloadProgress progress) const noexcept { + _function->operator()(progress); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void_NitroModelDownloadProgress create_Func_void_NitroModelDownloadProgress(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_NitroModelDownloadProgress_Wrapper wrap_Func_void_NitroModelDownloadProgress(Func_void_NitroModelDownloadProgress value) noexcept { + return Func_void_NitroModelDownloadProgress_Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr> + /** + * Specialized version of `std::shared_ptr>`. + */ + using std__shared_ptr_Promise_void__ = std::shared_ptr>; + inline std::shared_ptr> create_std__shared_ptr_Promise_void__() noexcept { + return Promise::create(); + } + inline PromiseHolder wrap_std__shared_ptr_Promise_void__(std::shared_ptr> promise) noexcept { + return PromiseHolder(std::move(promise)); + } + + // pragma MARK: std::function + /** + * Specialized version of `std::function`. + */ + using Func_void = std::function; + /** + * Wrapper class for a `std::function`, this can be used from Swift. + */ + class Func_void_Wrapper final { + public: + explicit Func_void_Wrapper(std::function&& func): _function(std::make_unique>(std::move(func))) {} + inline void call() const noexcept { + _function->operator()(); + } + private: + std::unique_ptr> _function; + } SWIFT_NONCOPYABLE; + Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept; + inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept { + return Func_void_Wrapper(std::move(value)); + } + + // pragma MARK: std::shared_ptr + /** + * Specialized version of `std::shared_ptr`. + */ + using std__shared_ptr_HybridOndeviceAiSpec_ = std::shared_ptr; + std::shared_ptr create_std__shared_ptr_HybridOndeviceAiSpec_(void* NON_NULL swiftUnsafePointer) noexcept; + void* NON_NULL get_std__shared_ptr_HybridOndeviceAiSpec_(std__shared_ptr_HybridOndeviceAiSpec_ cppType); + + // pragma MARK: std::weak_ptr + using std__weak_ptr_HybridOndeviceAiSpec_ = std::weak_ptr; + inline std__weak_ptr_HybridOndeviceAiSpec_ weakify_std__shared_ptr_HybridOndeviceAiSpec_(const std::shared_ptr& strong) noexcept { return strong; } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_bool___ = Result>>; + inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroDeviceCapability___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroDeviceCapability___ create_Result_std__shared_ptr_Promise_NitroDeviceCapability___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroDeviceCapability___ create_Result_std__shared_ptr_Promise_NitroDeviceCapability___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroSummarizeResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroSummarizeResult___ create_Result_std__shared_ptr_Promise_NitroSummarizeResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroSummarizeResult___ create_Result_std__shared_ptr_Promise_NitroSummarizeResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroClassifyResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroClassifyResult___ create_Result_std__shared_ptr_Promise_NitroClassifyResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroClassifyResult___ create_Result_std__shared_ptr_Promise_NitroClassifyResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroExtractResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroExtractResult___ create_Result_std__shared_ptr_Promise_NitroExtractResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroExtractResult___ create_Result_std__shared_ptr_Promise_NitroExtractResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroChatResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroChatResult___ create_Result_std__shared_ptr_Promise_NitroChatResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroChatResult___ create_Result_std__shared_ptr_Promise_NitroChatResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroTranslateResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroTranslateResult___ create_Result_std__shared_ptr_Promise_NitroTranslateResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroTranslateResult___ create_Result_std__shared_ptr_Promise_NitroTranslateResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroRewriteResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroRewriteResult___ create_Result_std__shared_ptr_Promise_NitroRewriteResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroRewriteResult___ create_Result_std__shared_ptr_Promise_NitroRewriteResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroProofreadResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroProofreadResult___ create_Result_std__shared_ptr_Promise_NitroProofreadResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroProofreadResult___ create_Result_std__shared_ptr_Promise_NitroProofreadResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result + using Result_void_ = Result; + inline Result_void_ create_Result_void_() noexcept { + return Result::withValue(); + } + inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept { + return Result::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroDescribeImageResult___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroDescribeImageResult___ create_Result_std__shared_ptr_Promise_NitroDescribeImageResult___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroDescribeImageResult___ create_Result_std__shared_ptr_Promise_NitroDescribeImageResult___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>>> + using Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____ = Result>>>; + inline Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____ create_Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____(const std::shared_ptr>>& value) noexcept { + return Result>>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____ create_Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____(const std::exception_ptr& error) noexcept { + return Result>>>::withError(error); + } + + // pragma MARK: Result>>> + using Result_std__shared_ptr_Promise_std__vector_std__string____ = Result>>>; + inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::shared_ptr>>& value) noexcept { + return Result>>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::exception_ptr& error) noexcept { + return Result>>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_std__string___ = Result>>; + inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_NitroInferenceEngine___ = Result>>; + inline Result_std__shared_ptr_Promise_NitroInferenceEngine___ create_Result_std__shared_ptr_Promise_NitroInferenceEngine___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_NitroInferenceEngine___ create_Result_std__shared_ptr_Promise_NitroInferenceEngine___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + + // pragma MARK: Result>> + using Result_std__shared_ptr_Promise_void___ = Result>>; + inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr>& value) noexcept { + return Result>>::withValue(value); + } + inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept { + return Result>>::withError(error); + } + +} // namespace margelo::nitro::ondeviceai::bridge::swift diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Umbrella.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Umbrella.hpp new file mode 100644 index 0000000..67c8b65 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAi-Swift-Cxx-Umbrella.hpp @@ -0,0 +1,143 @@ +/// +/// NitroOndeviceAi-Swift-Cxx-Umbrella.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +// Forward declarations of C++ defined types +// Forward declaration of `HybridOndeviceAiSpec` to properly resolve imports. +namespace margelo::nitro::ondeviceai { class HybridOndeviceAiSpec; } +// Forward declaration of `NitroChatMessageRole` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroChatMessageRole; } +// Forward declaration of `NitroChatMessage` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatMessage; } +// Forward declaration of `NitroChatOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatOptions; } +// Forward declaration of `NitroChatResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatResult; } +// Forward declaration of `NitroChatStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatStreamChunk; } +// Forward declaration of `NitroClassification` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassification; } +// Forward declaration of `NitroClassifyOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyOptions; } +// Forward declaration of `NitroClassifyResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyResult; } +// Forward declaration of `NitroDescribeImageOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageOptions; } +// Forward declaration of `NitroDescribeImageResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageResult; } +// Forward declaration of `NitroDeviceCapability` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDeviceCapability; } +// Forward declaration of `NitroExtractEntity` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractEntity; } +// Forward declaration of `NitroExtractOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractOptions; } +// Forward declaration of `NitroExtractResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractResult; } +// Forward declaration of `NitroInferenceEngine` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroInferenceEngine; } +// Forward declaration of `NitroModelDownloadProgress` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelDownloadProgress; } +// Forward declaration of `NitroModelDownloadState` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroModelDownloadState; } +// Forward declaration of `NitroModelInfo` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelInfo; } +// Forward declaration of `NitroProofreadCorrection` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadCorrection; } +// Forward declaration of `NitroProofreadResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadResult; } +// Forward declaration of `NitroRewriteOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteOptions; } +// Forward declaration of `NitroRewriteOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroRewriteOutputType; } +// Forward declaration of `NitroRewriteResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteResult; } +// Forward declaration of `NitroSummarizeInputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeInputType; } +// Forward declaration of `NitroSummarizeOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeOptions; } +// Forward declaration of `NitroSummarizeOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeOutputType; } +// Forward declaration of `NitroSummarizeResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeResult; } +// Forward declaration of `NitroTextStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTextStreamChunk; } +// Forward declaration of `NitroTranslateOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateOptions; } +// Forward declaration of `NitroTranslateResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateResult; } +// Forward declaration of `OndeviceAiPlatform` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class OndeviceAiPlatform; } + +// Include C++ defined types +#include "HybridOndeviceAiSpec.hpp" +#include "NitroChatMessage.hpp" +#include "NitroChatMessageRole.hpp" +#include "NitroChatOptions.hpp" +#include "NitroChatResult.hpp" +#include "NitroChatStreamChunk.hpp" +#include "NitroClassification.hpp" +#include "NitroClassifyOptions.hpp" +#include "NitroClassifyResult.hpp" +#include "NitroDescribeImageOptions.hpp" +#include "NitroDescribeImageResult.hpp" +#include "NitroDeviceCapability.hpp" +#include "NitroExtractEntity.hpp" +#include "NitroExtractOptions.hpp" +#include "NitroExtractResult.hpp" +#include "NitroInferenceEngine.hpp" +#include "NitroModelDownloadProgress.hpp" +#include "NitroModelDownloadState.hpp" +#include "NitroModelInfo.hpp" +#include "NitroProofreadCorrection.hpp" +#include "NitroProofreadResult.hpp" +#include "NitroRewriteOptions.hpp" +#include "NitroRewriteOutputType.hpp" +#include "NitroRewriteResult.hpp" +#include "NitroSummarizeInputType.hpp" +#include "NitroSummarizeOptions.hpp" +#include "NitroSummarizeOutputType.hpp" +#include "NitroSummarizeResult.hpp" +#include "NitroTextStreamChunk.hpp" +#include "NitroTranslateOptions.hpp" +#include "NitroTranslateResult.hpp" +#include "OndeviceAiPlatform.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// C++ helpers for Swift +#include "NitroOndeviceAi-Swift-Cxx-Bridge.hpp" + +// Common C++ types used in Swift +#include +#include +#include +#include + +// Forward declarations of Swift defined types +// Forward declaration of `HybridOndeviceAiSpec_cxx` to properly resolve imports. +namespace NitroOndeviceAi { class HybridOndeviceAiSpec_cxx; } + +// Include Swift defined types +#if __has_include("NitroOndeviceAi-Swift.h") +// This header is generated by Xcode/Swift on every app build. +// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroOndeviceAi". +#include "NitroOndeviceAi-Swift.h" +// Same as above, but used when building with frameworks (`use_frameworks`) +#elif __has_include() +#include +#else +#error NitroOndeviceAi's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroOndeviceAi", and try building the app first. +#endif diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAiAutolinking.mm b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAiAutolinking.mm new file mode 100644 index 0000000..dff6f10 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAiAutolinking.mm @@ -0,0 +1,33 @@ +/// +/// NitroOndeviceAiAutolinking.mm +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#import +#import +#import "NitroOndeviceAi-Swift-Cxx-Umbrella.hpp" +#import + +#include "HybridOndeviceAiSpecSwift.hpp" + +@interface NitroOndeviceAiAutolinking : NSObject +@end + +@implementation NitroOndeviceAiAutolinking + ++ (void) load { + using namespace margelo::nitro; + using namespace margelo::nitro::ondeviceai; + + HybridObjectRegistry::registerHybridObjectConstructor( + "OndeviceAi", + []() -> std::shared_ptr { + std::shared_ptr hybridObject = NitroOndeviceAi::NitroOndeviceAiAutolinking::createOndeviceAi(); + return hybridObject; + } + ); +} + +@end diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAiAutolinking.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAiAutolinking.swift new file mode 100644 index 0000000..48919ca --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/NitroOndeviceAiAutolinking.swift @@ -0,0 +1,25 @@ +/// +/// NitroOndeviceAiAutolinking.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +public final class NitroOndeviceAiAutolinking { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Creates an instance of a Swift class that implements `HybridOndeviceAiSpec`, + * and wraps it in a Swift class that can directly interop with C++ (`HybridOndeviceAiSpec_cxx`) + * + * This is generated by Nitrogen and will initialize the class specified + * in the `"autolinking"` property of `nitro.json` (in this case, `HybridOndeviceAi`). + */ + public static func createOndeviceAi() -> bridge.std__shared_ptr_HybridOndeviceAiSpec_ { + let hybridObject = HybridOndeviceAi() + return { () -> bridge.std__shared_ptr_HybridOndeviceAiSpec_ in + let __cxxWrapped = hybridObject.getCxxWrapper() + return __cxxWrapped.getCxxPart() + }() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/c++/HybridOndeviceAiSpecSwift.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/c++/HybridOndeviceAiSpecSwift.cpp new file mode 100644 index 0000000..402aaea --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/c++/HybridOndeviceAiSpecSwift.cpp @@ -0,0 +1,11 @@ +/// +/// HybridOndeviceAiSpecSwift.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "HybridOndeviceAiSpecSwift.hpp" + +namespace margelo::nitro::ondeviceai { +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/c++/HybridOndeviceAiSpecSwift.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/c++/HybridOndeviceAiSpecSwift.hpp new file mode 100644 index 0000000..9a81d76 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/c++/HybridOndeviceAiSpecSwift.hpp @@ -0,0 +1,410 @@ +/// +/// HybridOndeviceAiSpecSwift.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#include "HybridOndeviceAiSpec.hpp" + +// Forward declaration of `HybridOndeviceAiSpec_cxx` to properly resolve imports. +namespace NitroOndeviceAi { class HybridOndeviceAiSpec_cxx; } + +// Forward declaration of `NitroDeviceCapability` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDeviceCapability; } +// Forward declaration of `OndeviceAiPlatform` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class OndeviceAiPlatform; } +// Forward declaration of `NitroSummarizeResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeResult; } +// Forward declaration of `NitroSummarizeOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeOptions; } +// Forward declaration of `NitroSummarizeInputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeInputType; } +// Forward declaration of `NitroSummarizeOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeOutputType; } +// Forward declaration of `NitroClassifyResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyResult; } +// Forward declaration of `NitroClassification` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassification; } +// Forward declaration of `NitroClassifyOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyOptions; } +// Forward declaration of `NitroExtractResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractResult; } +// Forward declaration of `NitroExtractEntity` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractEntity; } +// Forward declaration of `NitroExtractOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractOptions; } +// Forward declaration of `NitroChatResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatResult; } +// Forward declaration of `NitroChatOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatOptions; } +// Forward declaration of `NitroChatMessage` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatMessage; } +// Forward declaration of `NitroChatMessageRole` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroChatMessageRole; } +// Forward declaration of `NitroTranslateResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateResult; } +// Forward declaration of `NitroTranslateOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateOptions; } +// Forward declaration of `NitroRewriteResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteResult; } +// Forward declaration of `NitroRewriteOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteOptions; } +// Forward declaration of `NitroRewriteOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroRewriteOutputType; } +// Forward declaration of `NitroProofreadResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadResult; } +// Forward declaration of `NitroProofreadCorrection` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadCorrection; } +// Forward declaration of `NitroChatStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatStreamChunk; } +// Forward declaration of `NitroTextStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTextStreamChunk; } +// Forward declaration of `NitroDescribeImageResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageResult; } +// Forward declaration of `NitroDescribeImageOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageOptions; } +// Forward declaration of `NitroModelInfo` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelInfo; } +// Forward declaration of `NitroInferenceEngine` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroInferenceEngine; } +// Forward declaration of `NitroModelDownloadProgress` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelDownloadProgress; } +// Forward declaration of `NitroModelDownloadState` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroModelDownloadState; } + +#include +#include "NitroDeviceCapability.hpp" +#include "OndeviceAiPlatform.hpp" +#include "NitroSummarizeResult.hpp" +#include +#include +#include "NitroSummarizeOptions.hpp" +#include +#include +#include "NitroSummarizeInputType.hpp" +#include "NitroSummarizeOutputType.hpp" +#include "NitroClassifyResult.hpp" +#include "NitroClassification.hpp" +#include +#include "NitroClassifyOptions.hpp" +#include "NitroExtractResult.hpp" +#include "NitroExtractEntity.hpp" +#include "NitroExtractOptions.hpp" +#include "NitroChatResult.hpp" +#include "NitroChatOptions.hpp" +#include "NitroChatMessage.hpp" +#include "NitroChatMessageRole.hpp" +#include "NitroTranslateResult.hpp" +#include "NitroTranslateOptions.hpp" +#include "NitroRewriteResult.hpp" +#include "NitroRewriteOptions.hpp" +#include "NitroRewriteOutputType.hpp" +#include "NitroProofreadResult.hpp" +#include "NitroProofreadCorrection.hpp" +#include "NitroChatStreamChunk.hpp" +#include +#include "NitroTextStreamChunk.hpp" +#include "NitroDescribeImageResult.hpp" +#include "NitroDescribeImageOptions.hpp" +#include "NitroModelInfo.hpp" +#include "NitroInferenceEngine.hpp" +#include "NitroModelDownloadProgress.hpp" +#include "NitroModelDownloadState.hpp" + +#include "NitroOndeviceAi-Swift-Cxx-Umbrella.hpp" + +namespace margelo::nitro::ondeviceai { + + /** + * The C++ part of HybridOndeviceAiSpec_cxx.swift. + * + * HybridOndeviceAiSpecSwift (C++) accesses HybridOndeviceAiSpec_cxx (Swift), and might + * contain some additional bridging code for C++ <> Swift interop. + * + * Since this obviously introduces an overhead, I hope at some point in + * the future, HybridOndeviceAiSpec_cxx can directly inherit from the C++ class HybridOndeviceAiSpec + * to simplify the whole structure and memory management. + */ + class HybridOndeviceAiSpecSwift: public virtual HybridOndeviceAiSpec { + public: + // Constructor from a Swift instance + explicit HybridOndeviceAiSpecSwift(const NitroOndeviceAi::HybridOndeviceAiSpec_cxx& swiftPart): + HybridObject(HybridOndeviceAiSpec::TAG), + _swiftPart(swiftPart) { } + + public: + // Get the Swift part + inline NitroOndeviceAi::HybridOndeviceAiSpec_cxx& getSwiftPart() noexcept { + return _swiftPart; + } + + public: + inline size_t getExternalMemorySize() noexcept override { + return _swiftPart.getMemorySize(); + } + void dispose() noexcept override { + _swiftPart.dispose(); + } + std::string toString() override { + return _swiftPart.toString(); + } + + public: + // Properties + + + public: + // Methods + inline std::shared_ptr> initialize() override { + auto __result = _swiftPart.initialize(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> getDeviceCapability() override { + auto __result = _swiftPart.getDeviceCapability(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> summarize(const std::string& text, const std::optional>& options) override { + auto __result = _swiftPart.summarize(text, options); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> classify(const std::string& text, const std::optional>& options) override { + auto __result = _swiftPart.classify(text, options); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> extract(const std::string& text, const std::optional>& options) override { + auto __result = _swiftPart.extract(text, options); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> chat(const std::string& message, const std::optional>& options) override { + auto __result = _swiftPart.chat(message, options); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> translate(const std::string& text, const NitroTranslateOptions& options) override { + auto __result = _swiftPart.translate(text, std::forward(options)); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> rewrite(const std::string& text, const NitroRewriteOptions& options) override { + auto __result = _swiftPart.rewrite(text, std::forward(options)); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> proofread(const std::string& text) override { + auto __result = _swiftPart.proofread(text); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> chatStream(const std::string& message, const std::optional>& options) override { + auto __result = _swiftPart.chatStream(message, options); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline void addChatStreamListener(const std::function& listener) override { + auto __result = _swiftPart.addChatStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline void removeChatStreamListener(const std::function& listener) override { + auto __result = _swiftPart.removeChatStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline std::shared_ptr> summarizeStreaming(const std::string& text, const std::optional>& options) override { + auto __result = _swiftPart.summarizeStreaming(text, options); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline void addSummarizeStreamListener(const std::function& listener) override { + auto __result = _swiftPart.addSummarizeStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline void removeSummarizeStreamListener(const std::function& listener) override { + auto __result = _swiftPart.removeSummarizeStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline std::shared_ptr> translateStreaming(const std::string& text, const NitroTranslateOptions& options) override { + auto __result = _swiftPart.translateStreaming(text, std::forward(options)); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline void addTranslateStreamListener(const std::function& listener) override { + auto __result = _swiftPart.addTranslateStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline void removeTranslateStreamListener(const std::function& listener) override { + auto __result = _swiftPart.removeTranslateStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline std::shared_ptr> rewriteStreaming(const std::string& text, const NitroRewriteOptions& options) override { + auto __result = _swiftPart.rewriteStreaming(text, std::forward(options)); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline void addRewriteStreamListener(const std::function& listener) override { + auto __result = _swiftPart.addRewriteStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline void removeRewriteStreamListener(const std::function& listener) override { + auto __result = _swiftPart.removeRewriteStreamListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline std::shared_ptr> describeImage(const std::string& imageUri, const std::optional>& options) override { + auto __result = _swiftPart.describeImage(imageUri, options); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr>> getAvailableModels() override { + auto __result = _swiftPart.getAvailableModels(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr>> getDownloadedModels() override { + auto __result = _swiftPart.getDownloadedModels(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> getLoadedModel() override { + auto __result = _swiftPart.getLoadedModel(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> getCurrentEngine() override { + auto __result = _swiftPart.getCurrentEngine(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> downloadModel(const std::string& modelId) override { + auto __result = _swiftPart.downloadModel(modelId); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline void addModelDownloadProgressListener(const std::function& listener) override { + auto __result = _swiftPart.addModelDownloadProgressListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline void removeModelDownloadProgressListener(const std::function& listener) override { + auto __result = _swiftPart.removeModelDownloadProgressListener(listener); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + } + inline std::shared_ptr> loadModel(const std::string& modelId) override { + auto __result = _swiftPart.loadModel(modelId); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> deleteModel(const std::string& modelId) override { + auto __result = _swiftPart.deleteModel(modelId); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> getPromptApiStatus() override { + auto __result = _swiftPart.getPromptApiStatus(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + inline std::shared_ptr> downloadPromptApiModel() override { + auto __result = _swiftPart.downloadPromptApiModel(); + if (__result.hasError()) [[unlikely]] { + std::rethrow_exception(__result.error()); + } + auto __value = std::move(__result.value()); + return __value; + } + + private: + NitroOndeviceAi::HybridOndeviceAiSpec_cxx _swiftPart; + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void.swift new file mode 100644 index 0000000..3fdf632 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void.swift @@ -0,0 +1,47 @@ +/// +/// Func_void.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `() -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: () -> Void + + public init(_ closure: @escaping () -> Void) { + self.closure = closure + } + + @inline(__always) + public func call() -> Void { + self.closure() + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroChatResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroChatResult.swift new file mode 100644 index 0000000..767a4e0 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroChatResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroChatResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroChatResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroChatResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroChatResult) -> Void + + public init(_ closure: @escaping (_ value: NitroChatResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroChatResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroChatResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroChatResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroChatStreamChunk.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroChatStreamChunk.swift new file mode 100644 index 0000000..bfd6562 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroChatStreamChunk.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroChatStreamChunk.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ chunk: NitroChatStreamChunk) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroChatStreamChunk { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ chunk: NitroChatStreamChunk) -> Void + + public init(_ closure: @escaping (_ chunk: NitroChatStreamChunk) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(chunk: NitroChatStreamChunk) -> Void { + self.closure(chunk) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroChatStreamChunk`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroChatStreamChunk { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroClassifyResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroClassifyResult.swift new file mode 100644 index 0000000..f2862ea --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroClassifyResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroClassifyResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroClassifyResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroClassifyResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroClassifyResult) -> Void + + public init(_ closure: @escaping (_ value: NitroClassifyResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroClassifyResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroClassifyResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroClassifyResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroDescribeImageResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroDescribeImageResult.swift new file mode 100644 index 0000000..e89140a --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroDescribeImageResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroDescribeImageResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroDescribeImageResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroDescribeImageResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroDescribeImageResult) -> Void + + public init(_ closure: @escaping (_ value: NitroDescribeImageResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroDescribeImageResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroDescribeImageResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroDescribeImageResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroDeviceCapability.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroDeviceCapability.swift new file mode 100644 index 0000000..2591f2b --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroDeviceCapability.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroDeviceCapability.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroDeviceCapability) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroDeviceCapability { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroDeviceCapability) -> Void + + public init(_ closure: @escaping (_ value: NitroDeviceCapability) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroDeviceCapability) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroDeviceCapability`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroDeviceCapability { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroExtractResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroExtractResult.swift new file mode 100644 index 0000000..e3d9dc2 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroExtractResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroExtractResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroExtractResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroExtractResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroExtractResult) -> Void + + public init(_ closure: @escaping (_ value: NitroExtractResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroExtractResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroExtractResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroExtractResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroInferenceEngine.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroInferenceEngine.swift new file mode 100644 index 0000000..95ee088 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroInferenceEngine.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroInferenceEngine.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroInferenceEngine) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroInferenceEngine { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroInferenceEngine) -> Void + + public init(_ closure: @escaping (_ value: NitroInferenceEngine) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: Int32) -> Void { + self.closure(margelo.nitro.ondeviceai.NitroInferenceEngine(rawValue: value)!) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroInferenceEngine`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroInferenceEngine { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroModelDownloadProgress.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroModelDownloadProgress.swift new file mode 100644 index 0000000..d95c81d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroModelDownloadProgress.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroModelDownloadProgress.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ progress: NitroModelDownloadProgress) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroModelDownloadProgress { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ progress: NitroModelDownloadProgress) -> Void + + public init(_ closure: @escaping (_ progress: NitroModelDownloadProgress) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(progress: NitroModelDownloadProgress) -> Void { + self.closure(progress) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroModelDownloadProgress`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroModelDownloadProgress { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroProofreadResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroProofreadResult.swift new file mode 100644 index 0000000..d1b4f85 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroProofreadResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroProofreadResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroProofreadResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroProofreadResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroProofreadResult) -> Void + + public init(_ closure: @escaping (_ value: NitroProofreadResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroProofreadResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroProofreadResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroProofreadResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroRewriteResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroRewriteResult.swift new file mode 100644 index 0000000..c89e7bf --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroRewriteResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroRewriteResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroRewriteResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroRewriteResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroRewriteResult) -> Void + + public init(_ closure: @escaping (_ value: NitroRewriteResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroRewriteResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroRewriteResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroRewriteResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroSummarizeResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroSummarizeResult.swift new file mode 100644 index 0000000..0eb7ff6 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroSummarizeResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroSummarizeResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroSummarizeResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroSummarizeResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroSummarizeResult) -> Void + + public init(_ closure: @escaping (_ value: NitroSummarizeResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroSummarizeResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroSummarizeResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroSummarizeResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroTextStreamChunk.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroTextStreamChunk.swift new file mode 100644 index 0000000..1630605 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroTextStreamChunk.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroTextStreamChunk.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ chunk: NitroTextStreamChunk) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroTextStreamChunk { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ chunk: NitroTextStreamChunk) -> Void + + public init(_ closure: @escaping (_ chunk: NitroTextStreamChunk) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(chunk: NitroTextStreamChunk) -> Void { + self.closure(chunk) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroTextStreamChunk`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroTextStreamChunk { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroTranslateResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroTranslateResult.swift new file mode 100644 index 0000000..404da07 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_NitroTranslateResult.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_NitroTranslateResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: NitroTranslateResult) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_NitroTranslateResult { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: NitroTranslateResult) -> Void + + public init(_ closure: @escaping (_ value: NitroTranslateResult) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: NitroTranslateResult) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_NitroTranslateResult`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_NitroTranslateResult { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_bool.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_bool.swift new file mode 100644 index 0000000..d764f65 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_bool.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_bool.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: Bool) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_bool { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: Bool) -> Void + + public init(_ closure: @escaping (_ value: Bool) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: Bool) -> Void { + self.closure(value) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_bool`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_bool { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift new file mode 100644 index 0000000..356fe8d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_std__exception_ptr.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ error: Error) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_std__exception_ptr { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ error: Error) -> Void + + public init(_ closure: @escaping (_ error: Error) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(error: std.exception_ptr) -> Void { + self.closure(RuntimeError.from(cppError: error)) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_std__exception_ptr`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__exception_ptr { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__string.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__string.swift new file mode 100644 index 0000000..a5371da --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__string.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_std__string.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: String) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_std__string { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: String) -> Void + + public init(_ closure: @escaping (_ value: String) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: std.string) -> Void { + self.closure(String(value)) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_std__string`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__string { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__vector_NitroModelInfo_.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__vector_NitroModelInfo_.swift new file mode 100644 index 0000000..337beb9 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__vector_NitroModelInfo_.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_std__vector_NitroModelInfo_.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: [NitroModelInfo]) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_std__vector_NitroModelInfo_ { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: [NitroModelInfo]) -> Void + + public init(_ closure: @escaping (_ value: [NitroModelInfo]) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: bridge.std__vector_NitroModelInfo_) -> Void { + self.closure(value.map({ __item in __item })) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_std__vector_NitroModelInfo_`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__vector_NitroModelInfo_ { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__vector_std__string_.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__vector_std__string_.swift new file mode 100644 index 0000000..3f9a8a7 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Func_void_std__vector_std__string_.swift @@ -0,0 +1,47 @@ +/// +/// Func_void_std__vector_std__string_.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Wraps a Swift `(_ value: [String]) -> Void` as a class. + * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`. + */ +public final class Func_void_std__vector_std__string_ { + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + private let closure: (_ value: [String]) -> Void + + public init(_ closure: @escaping (_ value: [String]) -> Void) { + self.closure = closure + } + + @inline(__always) + public func call(value: bridge.std__vector_std__string_) -> Void { + self.closure(value.map({ __item in String(__item) })) + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + @inline(__always) + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `Func_void_std__vector_std__string_`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + @inline(__always) + public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__vector_std__string_ { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/HybridOndeviceAiSpec.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/HybridOndeviceAiSpec.swift new file mode 100644 index 0000000..85f6134 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/HybridOndeviceAiSpec.swift @@ -0,0 +1,88 @@ +/// +/// HybridOndeviceAiSpec.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/// See ``HybridOndeviceAiSpec`` +public protocol HybridOndeviceAiSpec_protocol: HybridObject { + // Properties + + + // Methods + func initialize() throws -> Promise + func getDeviceCapability() throws -> Promise + func summarize(text: String, options: Variant_NullType_NitroSummarizeOptions?) throws -> Promise + func classify(text: String, options: Variant_NullType_NitroClassifyOptions?) throws -> Promise + func extract(text: String, options: Variant_NullType_NitroExtractOptions?) throws -> Promise + func chat(message: String, options: Variant_NullType_NitroChatOptions?) throws -> Promise + func translate(text: String, options: NitroTranslateOptions) throws -> Promise + func rewrite(text: String, options: NitroRewriteOptions) throws -> Promise + func proofread(text: String) throws -> Promise + func chatStream(message: String, options: Variant_NullType_NitroChatOptions?) throws -> Promise + func addChatStreamListener(listener: @escaping (_ chunk: NitroChatStreamChunk) -> Void) throws -> Void + func removeChatStreamListener(listener: @escaping (_ chunk: NitroChatStreamChunk) -> Void) throws -> Void + func summarizeStreaming(text: String, options: Variant_NullType_NitroSummarizeOptions?) throws -> Promise + func addSummarizeStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws -> Void + func removeSummarizeStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws -> Void + func translateStreaming(text: String, options: NitroTranslateOptions) throws -> Promise + func addTranslateStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws -> Void + func removeTranslateStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws -> Void + func rewriteStreaming(text: String, options: NitroRewriteOptions) throws -> Promise + func addRewriteStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws -> Void + func removeRewriteStreamListener(listener: @escaping (_ chunk: NitroTextStreamChunk) -> Void) throws -> Void + func describeImage(imageUri: String, options: Variant_NullType_NitroDescribeImageOptions?) throws -> Promise + func getAvailableModels() throws -> Promise<[NitroModelInfo]> + func getDownloadedModels() throws -> Promise<[String]> + func getLoadedModel() throws -> Promise + func getCurrentEngine() throws -> Promise + func downloadModel(modelId: String) throws -> Promise + func addModelDownloadProgressListener(listener: @escaping (_ progress: NitroModelDownloadProgress) -> Void) throws -> Void + func removeModelDownloadProgressListener(listener: @escaping (_ progress: NitroModelDownloadProgress) -> Void) throws -> Void + func loadModel(modelId: String) throws -> Promise + func deleteModel(modelId: String) throws -> Promise + func getPromptApiStatus() throws -> Promise + func downloadPromptApiModel() throws -> Promise +} + +public extension HybridOndeviceAiSpec_protocol { + /// Default implementation of ``HybridObject.toString`` + func toString() -> String { + return "[HybridObject OndeviceAi]" + } +} + +/// See ``HybridOndeviceAiSpec`` +open class HybridOndeviceAiSpec_base { + private weak var cxxWrapper: HybridOndeviceAiSpec_cxx? = nil + public init() { } + public func getCxxWrapper() -> HybridOndeviceAiSpec_cxx { + #if DEBUG + guard self is HybridOndeviceAiSpec else { + fatalError("`self` is not a `HybridOndeviceAiSpec`! Did you accidentally inherit from `HybridOndeviceAiSpec_base` instead of `HybridOndeviceAiSpec`?") + } + #endif + if let cxxWrapper = self.cxxWrapper { + return cxxWrapper + } else { + let cxxWrapper = HybridOndeviceAiSpec_cxx(self as! HybridOndeviceAiSpec) + self.cxxWrapper = cxxWrapper + return cxxWrapper + } + } +} + +/** + * A Swift base-protocol representing the OndeviceAi HybridObject. + * Implement this protocol to create Swift-based instances of OndeviceAi. + * ```swift + * class HybridOndeviceAi : HybridOndeviceAiSpec { + * // ... + * } + * ``` + */ +public typealias HybridOndeviceAiSpec = HybridOndeviceAiSpec_protocol & HybridOndeviceAiSpec_base diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/HybridOndeviceAiSpec_cxx.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/HybridOndeviceAiSpec_cxx.swift new file mode 100644 index 0000000..47df6f5 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/HybridOndeviceAiSpec_cxx.swift @@ -0,0 +1,861 @@ +/// +/// HybridOndeviceAiSpec_cxx.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * A class implementation that bridges HybridOndeviceAiSpec over to C++. + * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined. + * + * Also, some Swift types need to be bridged with special handling: + * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330) + * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper + * - Throwing methods need to be wrapped with a Result type, as exceptions cannot be propagated to C++ + */ +open class HybridOndeviceAiSpec_cxx { + /** + * The Swift <> C++ bridge's namespace (`margelo::nitro::ondeviceai::bridge::swift`) + * from `NitroOndeviceAi-Swift-Cxx-Bridge.hpp`. + * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift. + */ + public typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Holds an instance of the `HybridOndeviceAiSpec` Swift protocol. + */ + private var __implementation: any HybridOndeviceAiSpec + + /** + * Holds a weak pointer to the C++ class that wraps the Swift class. + */ + private var __cxxPart: bridge.std__weak_ptr_HybridOndeviceAiSpec_ + + /** + * Create a new `HybridOndeviceAiSpec_cxx` that wraps the given `HybridOndeviceAiSpec`. + * All properties and methods bridge to C++ types. + */ + public init(_ implementation: any HybridOndeviceAiSpec) { + self.__implementation = implementation + self.__cxxPart = .init() + /* no base class */ + } + + /** + * Get the actual `HybridOndeviceAiSpec` instance this class wraps. + */ + @inline(__always) + public func getHybridOndeviceAiSpec() -> any HybridOndeviceAiSpec { + return __implementation + } + + /** + * Casts this instance to a retained unsafe raw pointer. + * This acquires one additional strong reference on the object! + */ + public func toUnsafe() -> UnsafeMutableRawPointer { + return Unmanaged.passRetained(self).toOpaque() + } + + /** + * Casts an unsafe pointer to a `HybridOndeviceAiSpec_cxx`. + * The pointer has to be a retained opaque `Unmanaged`. + * This removes one strong reference from the object! + */ + public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridOndeviceAiSpec_cxx { + return Unmanaged.fromOpaque(pointer).takeRetainedValue() + } + + /** + * Gets (or creates) the C++ part of this Hybrid Object. + * The C++ part is a `std::shared_ptr`. + */ + public func getCxxPart() -> bridge.std__shared_ptr_HybridOndeviceAiSpec_ { + let cachedCxxPart = self.__cxxPart.lock() + if Bool(fromCxx: cachedCxxPart) { + return cachedCxxPart + } else { + let newCxxPart = bridge.create_std__shared_ptr_HybridOndeviceAiSpec_(self.toUnsafe()) + __cxxPart = bridge.weakify_std__shared_ptr_HybridOndeviceAiSpec_(newCxxPart) + return newCxxPart + } + } + + + + /** + * Get the memory size of the Swift class (plus size of any other allocations) + * so the JS VM can properly track it and garbage-collect the JS object if needed. + */ + @inline(__always) + public var memorySize: Int { + return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize + } + + /** + * Call dispose() on the Swift class. + * This _may_ be called manually from JS. + */ + @inline(__always) + public func dispose() { + self.__implementation.dispose() + } + + /** + * Call toString() on the Swift class. + */ + @inline(__always) + public func toString() -> String { + return self.__implementation.toString() + } + + // Properties + + + // Methods + @inline(__always) + public final func initialize() -> bridge.Result_std__shared_ptr_Promise_bool___ { + do { + let __result = try self.__implementation.initialize() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in + let __promise = bridge.create_std__shared_ptr_Promise_bool__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr) + } + } + + @inline(__always) + public final func getDeviceCapability() -> bridge.Result_std__shared_ptr_Promise_NitroDeviceCapability___ { + do { + let __result = try self.__implementation.getDeviceCapability() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroDeviceCapability__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroDeviceCapability__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroDeviceCapability__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroDeviceCapability___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroDeviceCapability___(__exceptionPtr) + } + } + + @inline(__always) + public final func summarize(text: std.string, options: bridge.std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__) -> bridge.Result_std__shared_ptr_Promise_NitroSummarizeResult___ { + do { + let __result = try self.__implementation.summarize(text: String(text), options: { () -> Variant_NullType_NitroSummarizeOptions? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__(options) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__(options) + return { () -> Variant_NullType_NitroSummarizeOptions in + let __variant = bridge.std__variant_nitro__NullType__NitroSummarizeOptions_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }()) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroSummarizeResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroSummarizeResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroSummarizeResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroSummarizeResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroSummarizeResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func classify(text: std.string, options: bridge.std__optional_std__variant_nitro__NullType__NitroClassifyOptions__) -> bridge.Result_std__shared_ptr_Promise_NitroClassifyResult___ { + do { + let __result = try self.__implementation.classify(text: String(text), options: { () -> Variant_NullType_NitroClassifyOptions? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__NitroClassifyOptions__(options) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__NitroClassifyOptions__(options) + return { () -> Variant_NullType_NitroClassifyOptions in + let __variant = bridge.std__variant_nitro__NullType__NitroClassifyOptions_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }()) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroClassifyResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroClassifyResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroClassifyResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroClassifyResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroClassifyResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func extract(text: std.string, options: bridge.std__optional_std__variant_nitro__NullType__NitroExtractOptions__) -> bridge.Result_std__shared_ptr_Promise_NitroExtractResult___ { + do { + let __result = try self.__implementation.extract(text: String(text), options: { () -> Variant_NullType_NitroExtractOptions? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__NitroExtractOptions__(options) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__NitroExtractOptions__(options) + return { () -> Variant_NullType_NitroExtractOptions in + let __variant = bridge.std__variant_nitro__NullType__NitroExtractOptions_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }()) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroExtractResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroExtractResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroExtractResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroExtractResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroExtractResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func chat(message: std.string, options: bridge.std__optional_std__variant_nitro__NullType__NitroChatOptions__) -> bridge.Result_std__shared_ptr_Promise_NitroChatResult___ { + do { + let __result = try self.__implementation.chat(message: String(message), options: { () -> Variant_NullType_NitroChatOptions? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__NitroChatOptions__(options) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__NitroChatOptions__(options) + return { () -> Variant_NullType_NitroChatOptions in + let __variant = bridge.std__variant_nitro__NullType__NitroChatOptions_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }()) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroChatResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroChatResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroChatResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroChatResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroChatResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func translate(text: std.string, options: NitroTranslateOptions) -> bridge.Result_std__shared_ptr_Promise_NitroTranslateResult___ { + do { + let __result = try self.__implementation.translate(text: String(text), options: options) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroTranslateResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroTranslateResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroTranslateResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroTranslateResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroTranslateResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func rewrite(text: std.string, options: NitroRewriteOptions) -> bridge.Result_std__shared_ptr_Promise_NitroRewriteResult___ { + do { + let __result = try self.__implementation.rewrite(text: String(text), options: options) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroRewriteResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroRewriteResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroRewriteResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroRewriteResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroRewriteResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func proofread(text: std.string) -> bridge.Result_std__shared_ptr_Promise_NitroProofreadResult___ { + do { + let __result = try self.__implementation.proofread(text: String(text)) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroProofreadResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroProofreadResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroProofreadResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroProofreadResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroProofreadResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func chatStream(message: std.string, options: bridge.std__optional_std__variant_nitro__NullType__NitroChatOptions__) -> bridge.Result_std__shared_ptr_Promise_NitroChatResult___ { + do { + let __result = try self.__implementation.chatStream(message: String(message), options: { () -> Variant_NullType_NitroChatOptions? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__NitroChatOptions__(options) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__NitroChatOptions__(options) + return { () -> Variant_NullType_NitroChatOptions in + let __variant = bridge.std__variant_nitro__NullType__NitroChatOptions_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }()) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroChatResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroChatResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroChatResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroChatResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroChatResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func addChatStreamListener(listener: bridge.Func_void_NitroChatStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.addChatStreamListener(listener: { () -> (NitroChatStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroChatStreamChunk(listener) + return { (__chunk: NitroChatStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func removeChatStreamListener(listener: bridge.Func_void_NitroChatStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.removeChatStreamListener(listener: { () -> (NitroChatStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroChatStreamChunk(listener) + return { (__chunk: NitroChatStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func summarizeStreaming(text: std.string, options: bridge.std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__) -> bridge.Result_std__shared_ptr_Promise_NitroSummarizeResult___ { + do { + let __result = try self.__implementation.summarizeStreaming(text: String(text), options: { () -> Variant_NullType_NitroSummarizeOptions? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__(options) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__NitroSummarizeOptions__(options) + return { () -> Variant_NullType_NitroSummarizeOptions in + let __variant = bridge.std__variant_nitro__NullType__NitroSummarizeOptions_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }()) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroSummarizeResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroSummarizeResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroSummarizeResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroSummarizeResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroSummarizeResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func addSummarizeStreamListener(listener: bridge.Func_void_NitroTextStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.addSummarizeStreamListener(listener: { () -> (NitroTextStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroTextStreamChunk(listener) + return { (__chunk: NitroTextStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func removeSummarizeStreamListener(listener: bridge.Func_void_NitroTextStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.removeSummarizeStreamListener(listener: { () -> (NitroTextStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroTextStreamChunk(listener) + return { (__chunk: NitroTextStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func translateStreaming(text: std.string, options: NitroTranslateOptions) -> bridge.Result_std__shared_ptr_Promise_NitroTranslateResult___ { + do { + let __result = try self.__implementation.translateStreaming(text: String(text), options: options) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroTranslateResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroTranslateResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroTranslateResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroTranslateResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroTranslateResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func addTranslateStreamListener(listener: bridge.Func_void_NitroTextStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.addTranslateStreamListener(listener: { () -> (NitroTextStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroTextStreamChunk(listener) + return { (__chunk: NitroTextStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func removeTranslateStreamListener(listener: bridge.Func_void_NitroTextStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.removeTranslateStreamListener(listener: { () -> (NitroTextStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroTextStreamChunk(listener) + return { (__chunk: NitroTextStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func rewriteStreaming(text: std.string, options: NitroRewriteOptions) -> bridge.Result_std__shared_ptr_Promise_NitroRewriteResult___ { + do { + let __result = try self.__implementation.rewriteStreaming(text: String(text), options: options) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroRewriteResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroRewriteResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroRewriteResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroRewriteResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroRewriteResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func addRewriteStreamListener(listener: bridge.Func_void_NitroTextStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.addRewriteStreamListener(listener: { () -> (NitroTextStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroTextStreamChunk(listener) + return { (__chunk: NitroTextStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func removeRewriteStreamListener(listener: bridge.Func_void_NitroTextStreamChunk) -> bridge.Result_void_ { + do { + try self.__implementation.removeRewriteStreamListener(listener: { () -> (NitroTextStreamChunk) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroTextStreamChunk(listener) + return { (__chunk: NitroTextStreamChunk) -> Void in + __wrappedFunction.call(__chunk) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func describeImage(imageUri: std.string, options: bridge.std__optional_std__variant_nitro__NullType__NitroDescribeImageOptions__) -> bridge.Result_std__shared_ptr_Promise_NitroDescribeImageResult___ { + do { + let __result = try self.__implementation.describeImage(imageUri: String(imageUri), options: { () -> Variant_NullType_NitroDescribeImageOptions? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__NitroDescribeImageOptions__(options) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__NitroDescribeImageOptions__(options) + return { () -> Variant_NullType_NitroDescribeImageOptions in + let __variant = bridge.std__variant_nitro__NullType__NitroDescribeImageOptions_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }()) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroDescribeImageResult__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroDescribeImageResult__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroDescribeImageResult__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroDescribeImageResult___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroDescribeImageResult___(__exceptionPtr) + } + } + + @inline(__always) + public final func getAvailableModels() -> bridge.Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____ { + do { + let __result = try self.__implementation.getAvailableModels() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_NitroModelInfo___ in + let __promise = bridge.create_std__shared_ptr_Promise_std__vector_NitroModelInfo___() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_NitroModelInfo___(__promise) + __result + .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_NitroModelInfo_ in + var __vector = bridge.create_std__vector_NitroModelInfo_(__result.count) + for __item in __result { + __vector.push_back(__item) + } + return __vector + }()) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_std__vector_NitroModelInfo____(__exceptionPtr) + } + } + + @inline(__always) + public final func getDownloadedModels() -> bridge.Result_std__shared_ptr_Promise_std__vector_std__string____ { + do { + let __result = try self.__implementation.getDownloadedModels() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_std__string___ in + let __promise = bridge.create_std__shared_ptr_Promise_std__vector_std__string___() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_std__string___(__promise) + __result + .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_std__string_ in + var __vector = bridge.create_std__vector_std__string_(__result.count) + for __item in __result { + __vector.push_back(std.string(__item)) + } + return __vector + }()) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__string____(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__string____(__exceptionPtr) + } + } + + @inline(__always) + public final func getLoadedModel() -> bridge.Result_std__shared_ptr_Promise_std__string___ { + do { + let __result = try self.__implementation.getLoadedModel() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in + let __promise = bridge.create_std__shared_ptr_Promise_std__string__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise) + __result + .then({ __result in __promiseHolder.resolve(std.string(__result)) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr) + } + } + + @inline(__always) + public final func getCurrentEngine() -> bridge.Result_std__shared_ptr_Promise_NitroInferenceEngine___ { + do { + let __result = try self.__implementation.getCurrentEngine() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_NitroInferenceEngine__ in + let __promise = bridge.create_std__shared_ptr_Promise_NitroInferenceEngine__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_NitroInferenceEngine__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_NitroInferenceEngine___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_NitroInferenceEngine___(__exceptionPtr) + } + } + + @inline(__always) + public final func downloadModel(modelId: std.string) -> bridge.Result_std__shared_ptr_Promise_bool___ { + do { + let __result = try self.__implementation.downloadModel(modelId: String(modelId)) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in + let __promise = bridge.create_std__shared_ptr_Promise_bool__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr) + } + } + + @inline(__always) + public final func addModelDownloadProgressListener(listener: bridge.Func_void_NitroModelDownloadProgress) -> bridge.Result_void_ { + do { + try self.__implementation.addModelDownloadProgressListener(listener: { () -> (NitroModelDownloadProgress) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroModelDownloadProgress(listener) + return { (__progress: NitroModelDownloadProgress) -> Void in + __wrappedFunction.call(__progress) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func removeModelDownloadProgressListener(listener: bridge.Func_void_NitroModelDownloadProgress) -> bridge.Result_void_ { + do { + try self.__implementation.removeModelDownloadProgressListener(listener: { () -> (NitroModelDownloadProgress) -> Void in + let __wrappedFunction = bridge.wrap_Func_void_NitroModelDownloadProgress(listener) + return { (__progress: NitroModelDownloadProgress) -> Void in + __wrappedFunction.call(__progress) + } + }()) + return bridge.create_Result_void_() + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_void_(__exceptionPtr) + } + } + + @inline(__always) + public final func loadModel(modelId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ { + do { + let __result = try self.__implementation.loadModel(modelId: String(modelId)) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in + let __promise = bridge.create_std__shared_ptr_Promise_void__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise) + __result + .then({ __result in __promiseHolder.resolve() }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr) + } + } + + @inline(__always) + public final func deleteModel(modelId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ { + do { + let __result = try self.__implementation.deleteModel(modelId: String(modelId)) + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in + let __promise = bridge.create_std__shared_ptr_Promise_void__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise) + __result + .then({ __result in __promiseHolder.resolve() }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr) + } + } + + @inline(__always) + public final func getPromptApiStatus() -> bridge.Result_std__shared_ptr_Promise_std__string___ { + do { + let __result = try self.__implementation.getPromptApiStatus() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in + let __promise = bridge.create_std__shared_ptr_Promise_std__string__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise) + __result + .then({ __result in __promiseHolder.resolve(std.string(__result)) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr) + } + } + + @inline(__always) + public final func downloadPromptApiModel() -> bridge.Result_std__shared_ptr_Promise_bool___ { + do { + let __result = try self.__implementation.downloadPromptApiModel() + let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in + let __promise = bridge.create_std__shared_ptr_Promise_bool__() + let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise) + __result + .then({ __result in __promiseHolder.resolve(__result) }) + .catch({ __error in __promiseHolder.reject(__error.toCpp()) }) + return __promise + }() + return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp) + } catch (let __error) { + let __exceptionPtr = __error.toCpp() + return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatMessage.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatMessage.swift new file mode 100644 index 0000000..b658d4f --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatMessage.swift @@ -0,0 +1,47 @@ +/// +/// NitroChatMessage.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroChatMessage`, backed by a C++ struct. + */ +public typealias NitroChatMessage = margelo.nitro.ondeviceai.NitroChatMessage + +public extension NitroChatMessage { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroChatMessage`. + */ + init(role: NitroChatMessageRole, content: String) { + self.init(role, std.string(content)) + } + + var role: NitroChatMessageRole { + @inline(__always) + get { + return self.__role + } + @inline(__always) + set { + self.__role = newValue + } + } + + var content: String { + @inline(__always) + get { + return String(self.__content) + } + @inline(__always) + set { + self.__content = std.string(newValue) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatMessageRole.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatMessageRole.swift new file mode 100644 index 0000000..95ec8ab --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatMessageRole.swift @@ -0,0 +1,44 @@ +/// +/// NitroChatMessageRole.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `NitroChatMessageRole`, backed by a C++ enum. + */ +public typealias NitroChatMessageRole = margelo.nitro.ondeviceai.NitroChatMessageRole + +public extension NitroChatMessageRole { + /** + * Get a NitroChatMessageRole for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "user": + self = .user + case "assistant": + self = .assistant + case "system": + self = .system + default: + return nil + } + } + + /** + * Get the String value this NitroChatMessageRole represents. + */ + var stringValue: String { + switch self { + case .user: + return "user" + case .assistant: + return "assistant" + case .system: + return "system" + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatOptions.swift new file mode 100644 index 0000000..774fb1f --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatOptions.swift @@ -0,0 +1,149 @@ +/// +/// NitroChatOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroChatOptions`, backed by a C++ struct. + */ +public typealias NitroChatOptions = margelo.nitro.ondeviceai.NitroChatOptions + +public extension NitroChatOptions { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroChatOptions`. + */ + init(systemPrompt: Variant_NullType_String?, history: Variant_NullType__NitroChatMessage_?) { + self.init({ () -> bridge.std__optional_std__variant_nitro__NullType__std__string__ in + if let __unwrappedValue = systemPrompt { + return bridge.create_std__optional_std__variant_nitro__NullType__std__string__({ () -> bridge.std__variant_nitro__NullType__std__string_ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value)) + } + }().variant) + } else { + return .init() + } + }(), { () -> bridge.std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___ in + if let __unwrappedValue = history { + return bridge.create_std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___({ () -> bridge.std__variant_nitro__NullType__std__vector_NitroChatMessage__ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_NitroChatMessage__(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_NitroChatMessage__({ () -> bridge.std__vector_NitroChatMessage_ in + var __vector = bridge.create_std__vector_NitroChatMessage_(__value.count) + for __item in __value { + __vector.push_back(__item) + } + return __vector + }()) + } + }().variant) + } else { + return .init() + } + }()) + } + + var systemPrompt: Variant_NullType_String? { + @inline(__always) + get { + return { () -> Variant_NullType_String? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__std__string__(self.__systemPrompt) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__std__string__(self.__systemPrompt) + return { () -> Variant_NullType_String in + let __variant = bridge.std__variant_nitro__NullType__std__string_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(String(__actual)) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }() + } + @inline(__always) + set { + self.__systemPrompt = { () -> bridge.std__optional_std__variant_nitro__NullType__std__string__ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_std__variant_nitro__NullType__std__string__({ () -> bridge.std__variant_nitro__NullType__std__string_ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value)) + } + }().variant) + } else { + return .init() + } + }() + } + } + + var history: Variant_NullType__NitroChatMessage_? { + @inline(__always) + get { + return { () -> Variant_NullType__NitroChatMessage_? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___(self.__history) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___(self.__history) + return { () -> Variant_NullType__NitroChatMessage_ in + let __variant = bridge.std__variant_nitro__NullType__std__vector_NitroChatMessage__(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual.map({ __item in __item })) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }() + } + @inline(__always) + set { + self.__history = { () -> bridge.std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_std__variant_nitro__NullType__std__vector_NitroChatMessage___({ () -> bridge.std__variant_nitro__NullType__std__vector_NitroChatMessage__ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_NitroChatMessage__(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_NitroChatMessage__({ () -> bridge.std__vector_NitroChatMessage_ in + var __vector = bridge.create_std__vector_NitroChatMessage_(__value.count) + for __item in __value { + __vector.push_back(__item) + } + return __vector + }()) + } + }().variant) + } else { + return .init() + } + }() + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatResult.swift new file mode 100644 index 0000000..219f700 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatResult.swift @@ -0,0 +1,58 @@ +/// +/// NitroChatResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroChatResult`, backed by a C++ struct. + */ +public typealias NitroChatResult = margelo.nitro.ondeviceai.NitroChatResult + +public extension NitroChatResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroChatResult`. + */ + init(message: String, conversationId: String, canContinue: Bool) { + self.init(std.string(message), std.string(conversationId), canContinue) + } + + var message: String { + @inline(__always) + get { + return String(self.__message) + } + @inline(__always) + set { + self.__message = std.string(newValue) + } + } + + var conversationId: String { + @inline(__always) + get { + return String(self.__conversationId) + } + @inline(__always) + set { + self.__conversationId = std.string(newValue) + } + } + + var canContinue: Bool { + @inline(__always) + get { + return self.__canContinue + } + @inline(__always) + set { + self.__canContinue = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatStreamChunk.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatStreamChunk.swift new file mode 100644 index 0000000..d09a71b --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroChatStreamChunk.swift @@ -0,0 +1,58 @@ +/// +/// NitroChatStreamChunk.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroChatStreamChunk`, backed by a C++ struct. + */ +public typealias NitroChatStreamChunk = margelo.nitro.ondeviceai.NitroChatStreamChunk + +public extension NitroChatStreamChunk { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroChatStreamChunk`. + */ + init(delta: String, accumulated: String, isFinal: Bool) { + self.init(std.string(delta), std.string(accumulated), isFinal) + } + + var delta: String { + @inline(__always) + get { + return String(self.__delta) + } + @inline(__always) + set { + self.__delta = std.string(newValue) + } + } + + var accumulated: String { + @inline(__always) + get { + return String(self.__accumulated) + } + @inline(__always) + set { + self.__accumulated = std.string(newValue) + } + } + + var isFinal: Bool { + @inline(__always) + get { + return self.__isFinal + } + @inline(__always) + set { + self.__isFinal = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassification.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassification.swift new file mode 100644 index 0000000..354328e --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassification.swift @@ -0,0 +1,58 @@ +/// +/// NitroClassification.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroClassification`, backed by a C++ struct. + */ +public typealias NitroClassification = margelo.nitro.ondeviceai.NitroClassification + +public extension NitroClassification { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroClassification`. + */ + init(label: String, score: Double, metadata: String) { + self.init(std.string(label), score, std.string(metadata)) + } + + var label: String { + @inline(__always) + get { + return String(self.__label) + } + @inline(__always) + set { + self.__label = std.string(newValue) + } + } + + var score: Double { + @inline(__always) + get { + return self.__score + } + @inline(__always) + set { + self.__score = newValue + } + } + + var metadata: String { + @inline(__always) + get { + return String(self.__metadata) + } + @inline(__always) + set { + self.__metadata = std.string(newValue) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassifyOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassifyOptions.swift new file mode 100644 index 0000000..11abc2a --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassifyOptions.swift @@ -0,0 +1,149 @@ +/// +/// NitroClassifyOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroClassifyOptions`, backed by a C++ struct. + */ +public typealias NitroClassifyOptions = margelo.nitro.ondeviceai.NitroClassifyOptions + +public extension NitroClassifyOptions { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroClassifyOptions`. + */ + init(categories: Variant_NullType__String_?, maxResults: Variant_NullType_Double?) { + self.init({ () -> bridge.std__optional_std__variant_nitro__NullType__std__vector_std__string___ in + if let __unwrappedValue = categories { + return bridge.create_std__optional_std__variant_nitro__NullType__std__vector_std__string___({ () -> bridge.std__variant_nitro__NullType__std__vector_std__string__ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__({ () -> bridge.std__vector_std__string_ in + var __vector = bridge.create_std__vector_std__string_(__value.count) + for __item in __value { + __vector.push_back(std.string(__item)) + } + return __vector + }()) + } + }().variant) + } else { + return .init() + } + }(), { () -> bridge.std__optional_std__variant_nitro__NullType__double__ in + if let __unwrappedValue = maxResults { + return bridge.create_std__optional_std__variant_nitro__NullType__double__({ () -> bridge.std__variant_nitro__NullType__double_ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__double_(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__double_(__value) + } + }().variant) + } else { + return .init() + } + }()) + } + + var categories: Variant_NullType__String_? { + @inline(__always) + get { + return { () -> Variant_NullType__String_? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__std__vector_std__string___(self.__categories) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__std__vector_std__string___(self.__categories) + return { () -> Variant_NullType__String_ in + let __variant = bridge.std__variant_nitro__NullType__std__vector_std__string__(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual.map({ __item in String(__item) })) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }() + } + @inline(__always) + set { + self.__categories = { () -> bridge.std__optional_std__variant_nitro__NullType__std__vector_std__string___ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_std__variant_nitro__NullType__std__vector_std__string___({ () -> bridge.std__variant_nitro__NullType__std__vector_std__string__ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__({ () -> bridge.std__vector_std__string_ in + var __vector = bridge.create_std__vector_std__string_(__value.count) + for __item in __value { + __vector.push_back(std.string(__item)) + } + return __vector + }()) + } + }().variant) + } else { + return .init() + } + }() + } + } + + var maxResults: Variant_NullType_Double? { + @inline(__always) + get { + return { () -> Variant_NullType_Double? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__double__(self.__maxResults) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__double__(self.__maxResults) + return { () -> Variant_NullType_Double in + let __variant = bridge.std__variant_nitro__NullType__double_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }() + } + @inline(__always) + set { + self.__maxResults = { () -> bridge.std__optional_std__variant_nitro__NullType__double__ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_std__variant_nitro__NullType__double__({ () -> bridge.std__variant_nitro__NullType__double_ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__double_(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__double_(__value) + } + }().variant) + } else { + return .init() + } + }() + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassifyResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassifyResult.swift new file mode 100644 index 0000000..c71324f --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroClassifyResult.swift @@ -0,0 +1,70 @@ +/// +/// NitroClassifyResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroClassifyResult`, backed by a C++ struct. + */ +public typealias NitroClassifyResult = margelo.nitro.ondeviceai.NitroClassifyResult + +public extension NitroClassifyResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroClassifyResult`. + */ + init(classifications: [NitroClassification], topLabel: String, topScore: Double) { + self.init({ () -> bridge.std__vector_NitroClassification_ in + var __vector = bridge.create_std__vector_NitroClassification_(classifications.count) + for __item in classifications { + __vector.push_back(__item) + } + return __vector + }(), std.string(topLabel), topScore) + } + + var classifications: [NitroClassification] { + @inline(__always) + get { + return self.__classifications.map({ __item in __item }) + } + @inline(__always) + set { + self.__classifications = { () -> bridge.std__vector_NitroClassification_ in + var __vector = bridge.create_std__vector_NitroClassification_(newValue.count) + for __item in newValue { + __vector.push_back(__item) + } + return __vector + }() + } + } + + var topLabel: String { + @inline(__always) + get { + return String(self.__topLabel) + } + @inline(__always) + set { + self.__topLabel = std.string(newValue) + } + } + + var topScore: Double { + @inline(__always) + get { + return self.__topScore + } + @inline(__always) + set { + self.__topScore = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDescribeImageOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDescribeImageOptions.swift new file mode 100644 index 0000000..c74cd16 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDescribeImageOptions.swift @@ -0,0 +1,81 @@ +/// +/// NitroDescribeImageOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroDescribeImageOptions`, backed by a C++ struct. + */ +public typealias NitroDescribeImageOptions = margelo.nitro.ondeviceai.NitroDescribeImageOptions + +public extension NitroDescribeImageOptions { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroDescribeImageOptions`. + */ + init(prompt: Variant_NullType_String?) { + self.init({ () -> bridge.std__optional_std__variant_nitro__NullType__std__string__ in + if let __unwrappedValue = prompt { + return bridge.create_std__optional_std__variant_nitro__NullType__std__string__({ () -> bridge.std__variant_nitro__NullType__std__string_ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value)) + } + }().variant) + } else { + return .init() + } + }()) + } + + var prompt: Variant_NullType_String? { + @inline(__always) + get { + return { () -> Variant_NullType_String? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__std__string__(self.__prompt) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__std__string__(self.__prompt) + return { () -> Variant_NullType_String in + let __variant = bridge.std__variant_nitro__NullType__std__string_(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(String(__actual)) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }() + } + @inline(__always) + set { + self.__prompt = { () -> bridge.std__optional_std__variant_nitro__NullType__std__string__ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_std__variant_nitro__NullType__std__string__({ () -> bridge.std__variant_nitro__NullType__std__string_ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value)) + } + }().variant) + } else { + return .init() + } + }() + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDescribeImageResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDescribeImageResult.swift new file mode 100644 index 0000000..d4a1763 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDescribeImageResult.swift @@ -0,0 +1,47 @@ +/// +/// NitroDescribeImageResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroDescribeImageResult`, backed by a C++ struct. + */ +public typealias NitroDescribeImageResult = margelo.nitro.ondeviceai.NitroDescribeImageResult + +public extension NitroDescribeImageResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroDescribeImageResult`. + */ + init(description: String, confidence: Double) { + self.init(std.string(description), confidence) + } + + var description: String { + @inline(__always) + get { + return String(self.__description) + } + @inline(__always) + set { + self.__description = std.string(newValue) + } + } + + var confidence: Double { + @inline(__always) + get { + return self.__confidence + } + @inline(__always) + set { + self.__confidence = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDeviceCapability.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDeviceCapability.swift new file mode 100644 index 0000000..1af58f4 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroDeviceCapability.swift @@ -0,0 +1,168 @@ +/// +/// NitroDeviceCapability.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroDeviceCapability`, backed by a C++ struct. + */ +public typealias NitroDeviceCapability = margelo.nitro.ondeviceai.NitroDeviceCapability + +public extension NitroDeviceCapability { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroDeviceCapability`. + */ + init(isSupported: Bool, isModelReady: Bool, supportsAppleIntelligence: Bool, platform: OndeviceAiPlatform, featureSummarize: Bool, featureClassify: Bool, featureExtract: Bool, featureChat: Bool, featureTranslate: Bool, featureRewrite: Bool, featureProofread: Bool, availableMemoryMB: Double, isLowPowerMode: Bool) { + self.init(isSupported, isModelReady, supportsAppleIntelligence, platform, featureSummarize, featureClassify, featureExtract, featureChat, featureTranslate, featureRewrite, featureProofread, availableMemoryMB, isLowPowerMode) + } + + var isSupported: Bool { + @inline(__always) + get { + return self.__isSupported + } + @inline(__always) + set { + self.__isSupported = newValue + } + } + + var isModelReady: Bool { + @inline(__always) + get { + return self.__isModelReady + } + @inline(__always) + set { + self.__isModelReady = newValue + } + } + + var supportsAppleIntelligence: Bool { + @inline(__always) + get { + return self.__supportsAppleIntelligence + } + @inline(__always) + set { + self.__supportsAppleIntelligence = newValue + } + } + + var platform: OndeviceAiPlatform { + @inline(__always) + get { + return self.__platform + } + @inline(__always) + set { + self.__platform = newValue + } + } + + var featureSummarize: Bool { + @inline(__always) + get { + return self.__featureSummarize + } + @inline(__always) + set { + self.__featureSummarize = newValue + } + } + + var featureClassify: Bool { + @inline(__always) + get { + return self.__featureClassify + } + @inline(__always) + set { + self.__featureClassify = newValue + } + } + + var featureExtract: Bool { + @inline(__always) + get { + return self.__featureExtract + } + @inline(__always) + set { + self.__featureExtract = newValue + } + } + + var featureChat: Bool { + @inline(__always) + get { + return self.__featureChat + } + @inline(__always) + set { + self.__featureChat = newValue + } + } + + var featureTranslate: Bool { + @inline(__always) + get { + return self.__featureTranslate + } + @inline(__always) + set { + self.__featureTranslate = newValue + } + } + + var featureRewrite: Bool { + @inline(__always) + get { + return self.__featureRewrite + } + @inline(__always) + set { + self.__featureRewrite = newValue + } + } + + var featureProofread: Bool { + @inline(__always) + get { + return self.__featureProofread + } + @inline(__always) + set { + self.__featureProofread = newValue + } + } + + var availableMemoryMB: Double { + @inline(__always) + get { + return self.__availableMemoryMB + } + @inline(__always) + set { + self.__availableMemoryMB = newValue + } + } + + var isLowPowerMode: Bool { + @inline(__always) + get { + return self.__isLowPowerMode + } + @inline(__always) + set { + self.__isLowPowerMode = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractEntity.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractEntity.swift new file mode 100644 index 0000000..8b01f24 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractEntity.swift @@ -0,0 +1,80 @@ +/// +/// NitroExtractEntity.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroExtractEntity`, backed by a C++ struct. + */ +public typealias NitroExtractEntity = margelo.nitro.ondeviceai.NitroExtractEntity + +public extension NitroExtractEntity { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroExtractEntity`. + */ + init(type: String, value: String, confidence: Double, startPos: Double, endPos: Double) { + self.init(std.string(type), std.string(value), confidence, startPos, endPos) + } + + var type: String { + @inline(__always) + get { + return String(self.__type) + } + @inline(__always) + set { + self.__type = std.string(newValue) + } + } + + var value: String { + @inline(__always) + get { + return String(self.__value) + } + @inline(__always) + set { + self.__value = std.string(newValue) + } + } + + var confidence: Double { + @inline(__always) + get { + return self.__confidence + } + @inline(__always) + set { + self.__confidence = newValue + } + } + + var startPos: Double { + @inline(__always) + get { + return self.__startPos + } + @inline(__always) + set { + self.__startPos = newValue + } + } + + var endPos: Double { + @inline(__always) + get { + return self.__endPos + } + @inline(__always) + set { + self.__endPos = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractOptions.swift new file mode 100644 index 0000000..d51f426 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractOptions.swift @@ -0,0 +1,93 @@ +/// +/// NitroExtractOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroExtractOptions`, backed by a C++ struct. + */ +public typealias NitroExtractOptions = margelo.nitro.ondeviceai.NitroExtractOptions + +public extension NitroExtractOptions { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroExtractOptions`. + */ + init(entityTypes: Variant_NullType__String_?) { + self.init({ () -> bridge.std__optional_std__variant_nitro__NullType__std__vector_std__string___ in + if let __unwrappedValue = entityTypes { + return bridge.create_std__optional_std__variant_nitro__NullType__std__vector_std__string___({ () -> bridge.std__variant_nitro__NullType__std__vector_std__string__ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__({ () -> bridge.std__vector_std__string_ in + var __vector = bridge.create_std__vector_std__string_(__value.count) + for __item in __value { + __vector.push_back(std.string(__item)) + } + return __vector + }()) + } + }().variant) + } else { + return .init() + } + }()) + } + + var entityTypes: Variant_NullType__String_? { + @inline(__always) + get { + return { () -> Variant_NullType__String_? in + if bridge.has_value_std__optional_std__variant_nitro__NullType__std__vector_std__string___(self.__entityTypes) { + let __unwrapped = bridge.get_std__optional_std__variant_nitro__NullType__std__vector_std__string___(self.__entityTypes) + return { () -> Variant_NullType__String_ in + let __variant = bridge.std__variant_nitro__NullType__std__vector_std__string__(__unwrapped) + switch __variant.index() { + case 0: + let __actual = __variant.get_0() + return .first(NullType.null) + case 1: + let __actual = __variant.get_1() + return .second(__actual.map({ __item in String(__item) })) + default: + fatalError("Variant can never have index \(__variant.index())!") + } + }() + } else { + return nil + } + }() + } + @inline(__always) + set { + self.__entityTypes = { () -> bridge.std__optional_std__variant_nitro__NullType__std__vector_std__string___ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_std__variant_nitro__NullType__std__vector_std__string___({ () -> bridge.std__variant_nitro__NullType__std__vector_std__string__ in + switch __unwrappedValue { + case .first(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__(margelo.nitro.NullType.null) + case .second(let __value): + return bridge.create_std__variant_nitro__NullType__std__vector_std__string__({ () -> bridge.std__vector_std__string_ in + var __vector = bridge.create_std__vector_std__string_(__value.count) + for __item in __value { + __vector.push_back(std.string(__item)) + } + return __vector + }()) + } + }().variant) + } else { + return .init() + } + }() + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractResult.swift new file mode 100644 index 0000000..1d87b54 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroExtractResult.swift @@ -0,0 +1,48 @@ +/// +/// NitroExtractResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroExtractResult`, backed by a C++ struct. + */ +public typealias NitroExtractResult = margelo.nitro.ondeviceai.NitroExtractResult + +public extension NitroExtractResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroExtractResult`. + */ + init(entities: [NitroExtractEntity]) { + self.init({ () -> bridge.std__vector_NitroExtractEntity_ in + var __vector = bridge.create_std__vector_NitroExtractEntity_(entities.count) + for __item in entities { + __vector.push_back(__item) + } + return __vector + }()) + } + + var entities: [NitroExtractEntity] { + @inline(__always) + get { + return self.__entities.map({ __item in __item }) + } + @inline(__always) + set { + self.__entities = { () -> bridge.std__vector_NitroExtractEntity_ in + var __vector = bridge.create_std__vector_NitroExtractEntity_(newValue.count) + for __item in newValue { + __vector.push_back(__item) + } + return __vector + }() + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroInferenceEngine.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroInferenceEngine.swift new file mode 100644 index 0000000..628fff7 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroInferenceEngine.swift @@ -0,0 +1,56 @@ +/// +/// NitroInferenceEngine.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `NitroInferenceEngine`, backed by a C++ enum. + */ +public typealias NitroInferenceEngine = margelo.nitro.ondeviceai.NitroInferenceEngine + +public extension NitroInferenceEngine { + /** + * Get a NitroInferenceEngine for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "foundation_models": + self = .foundationModels + case "llama_cpp": + self = .llamaCpp + case "mlx": + self = .mlx + case "core_ml": + self = .coreMl + case "prompt_api": + self = .promptApi + case "none": + self = .none + default: + return nil + } + } + + /** + * Get the String value this NitroInferenceEngine represents. + */ + var stringValue: String { + switch self { + case .foundationModels: + return "foundation_models" + case .llamaCpp: + return "llama_cpp" + case .mlx: + return "mlx" + case .coreMl: + return "core_ml" + case .promptApi: + return "prompt_api" + case .none: + return "none" + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelDownloadProgress.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelDownloadProgress.swift new file mode 100644 index 0000000..32cfa26 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelDownloadProgress.swift @@ -0,0 +1,80 @@ +/// +/// NitroModelDownloadProgress.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroModelDownloadProgress`, backed by a C++ struct. + */ +public typealias NitroModelDownloadProgress = margelo.nitro.ondeviceai.NitroModelDownloadProgress + +public extension NitroModelDownloadProgress { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroModelDownloadProgress`. + */ + init(modelId: String, bytesDownloaded: Double, totalBytes: Double, progress: Double, state: NitroModelDownloadState) { + self.init(std.string(modelId), bytesDownloaded, totalBytes, progress, state) + } + + var modelId: String { + @inline(__always) + get { + return String(self.__modelId) + } + @inline(__always) + set { + self.__modelId = std.string(newValue) + } + } + + var bytesDownloaded: Double { + @inline(__always) + get { + return self.__bytesDownloaded + } + @inline(__always) + set { + self.__bytesDownloaded = newValue + } + } + + var totalBytes: Double { + @inline(__always) + get { + return self.__totalBytes + } + @inline(__always) + set { + self.__totalBytes = newValue + } + } + + var progress: Double { + @inline(__always) + get { + return self.__progress + } + @inline(__always) + set { + self.__progress = newValue + } + } + + var state: NitroModelDownloadState { + @inline(__always) + get { + return self.__state + } + @inline(__always) + set { + self.__state = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelDownloadState.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelDownloadState.swift new file mode 100644 index 0000000..c6df5e5 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelDownloadState.swift @@ -0,0 +1,56 @@ +/// +/// NitroModelDownloadState.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `NitroModelDownloadState`, backed by a C++ enum. + */ +public typealias NitroModelDownloadState = margelo.nitro.ondeviceai.NitroModelDownloadState + +public extension NitroModelDownloadState { + /** + * Get a NitroModelDownloadState for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "pending": + self = .pending + case "downloading": + self = .downloading + case "verifying": + self = .verifying + case "completed": + self = .completed + case "failed": + self = .failed + case "cancelled": + self = .cancelled + default: + return nil + } + } + + /** + * Get the String value this NitroModelDownloadState represents. + */ + var stringValue: String { + switch self { + case .pending: + return "pending" + case .downloading: + return "downloading" + case .verifying: + return "verifying" + case .completed: + return "completed" + case .failed: + return "failed" + case .cancelled: + return "cancelled" + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelInfo.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelInfo.swift new file mode 100644 index 0000000..4046636 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroModelInfo.swift @@ -0,0 +1,113 @@ +/// +/// NitroModelInfo.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroModelInfo`, backed by a C++ struct. + */ +public typealias NitroModelInfo = margelo.nitro.ondeviceai.NitroModelInfo + +public extension NitroModelInfo { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroModelInfo`. + */ + init(modelId: String, name: String, version: String, sizeMB: Double, quantization: String, contextLength: Double, minMemoryMB: Double, isMultimodal: Bool) { + self.init(std.string(modelId), std.string(name), std.string(version), sizeMB, std.string(quantization), contextLength, minMemoryMB, isMultimodal) + } + + var modelId: String { + @inline(__always) + get { + return String(self.__modelId) + } + @inline(__always) + set { + self.__modelId = std.string(newValue) + } + } + + var name: String { + @inline(__always) + get { + return String(self.__name) + } + @inline(__always) + set { + self.__name = std.string(newValue) + } + } + + var version: String { + @inline(__always) + get { + return String(self.__version) + } + @inline(__always) + set { + self.__version = std.string(newValue) + } + } + + var sizeMB: Double { + @inline(__always) + get { + return self.__sizeMB + } + @inline(__always) + set { + self.__sizeMB = newValue + } + } + + var quantization: String { + @inline(__always) + get { + return String(self.__quantization) + } + @inline(__always) + set { + self.__quantization = std.string(newValue) + } + } + + var contextLength: Double { + @inline(__always) + get { + return self.__contextLength + } + @inline(__always) + set { + self.__contextLength = newValue + } + } + + var minMemoryMB: Double { + @inline(__always) + get { + return self.__minMemoryMB + } + @inline(__always) + set { + self.__minMemoryMB = newValue + } + } + + var isMultimodal: Bool { + @inline(__always) + get { + return self.__isMultimodal + } + @inline(__always) + set { + self.__isMultimodal = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroProofreadCorrection.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroProofreadCorrection.swift new file mode 100644 index 0000000..c5efd78 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroProofreadCorrection.swift @@ -0,0 +1,91 @@ +/// +/// NitroProofreadCorrection.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroProofreadCorrection`, backed by a C++ struct. + */ +public typealias NitroProofreadCorrection = margelo.nitro.ondeviceai.NitroProofreadCorrection + +public extension NitroProofreadCorrection { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroProofreadCorrection`. + */ + init(original: String, corrected: String, type: String, confidence: Double, startPos: Double, endPos: Double) { + self.init(std.string(original), std.string(corrected), std.string(type), confidence, startPos, endPos) + } + + var original: String { + @inline(__always) + get { + return String(self.__original) + } + @inline(__always) + set { + self.__original = std.string(newValue) + } + } + + var corrected: String { + @inline(__always) + get { + return String(self.__corrected) + } + @inline(__always) + set { + self.__corrected = std.string(newValue) + } + } + + var type: String { + @inline(__always) + get { + return String(self.__type) + } + @inline(__always) + set { + self.__type = std.string(newValue) + } + } + + var confidence: Double { + @inline(__always) + get { + return self.__confidence + } + @inline(__always) + set { + self.__confidence = newValue + } + } + + var startPos: Double { + @inline(__always) + get { + return self.__startPos + } + @inline(__always) + set { + self.__startPos = newValue + } + } + + var endPos: Double { + @inline(__always) + get { + return self.__endPos + } + @inline(__always) + set { + self.__endPos = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroProofreadResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroProofreadResult.swift new file mode 100644 index 0000000..3affbf8 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroProofreadResult.swift @@ -0,0 +1,70 @@ +/// +/// NitroProofreadResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroProofreadResult`, backed by a C++ struct. + */ +public typealias NitroProofreadResult = margelo.nitro.ondeviceai.NitroProofreadResult + +public extension NitroProofreadResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroProofreadResult`. + */ + init(correctedText: String, corrections: [NitroProofreadCorrection], hasCorrections: Bool) { + self.init(std.string(correctedText), { () -> bridge.std__vector_NitroProofreadCorrection_ in + var __vector = bridge.create_std__vector_NitroProofreadCorrection_(corrections.count) + for __item in corrections { + __vector.push_back(__item) + } + return __vector + }(), hasCorrections) + } + + var correctedText: String { + @inline(__always) + get { + return String(self.__correctedText) + } + @inline(__always) + set { + self.__correctedText = std.string(newValue) + } + } + + var corrections: [NitroProofreadCorrection] { + @inline(__always) + get { + return self.__corrections.map({ __item in __item }) + } + @inline(__always) + set { + self.__corrections = { () -> bridge.std__vector_NitroProofreadCorrection_ in + var __vector = bridge.create_std__vector_NitroProofreadCorrection_(newValue.count) + for __item in newValue { + __vector.push_back(__item) + } + return __vector + }() + } + } + + var hasCorrections: Bool { + @inline(__always) + get { + return self.__hasCorrections + } + @inline(__always) + set { + self.__hasCorrections = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteOptions.swift new file mode 100644 index 0000000..7b453e2 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteOptions.swift @@ -0,0 +1,36 @@ +/// +/// NitroRewriteOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroRewriteOptions`, backed by a C++ struct. + */ +public typealias NitroRewriteOptions = margelo.nitro.ondeviceai.NitroRewriteOptions + +public extension NitroRewriteOptions { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroRewriteOptions`. + */ + init(outputType: NitroRewriteOutputType) { + self.init(outputType) + } + + var outputType: NitroRewriteOutputType { + @inline(__always) + get { + return self.__outputType + } + @inline(__always) + set { + self.__outputType = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteOutputType.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteOutputType.swift new file mode 100644 index 0000000..0fb5106 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteOutputType.swift @@ -0,0 +1,56 @@ +/// +/// NitroRewriteOutputType.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `NitroRewriteOutputType`, backed by a C++ enum. + */ +public typealias NitroRewriteOutputType = margelo.nitro.ondeviceai.NitroRewriteOutputType + +public extension NitroRewriteOutputType { + /** + * Get a NitroRewriteOutputType for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "ELABORATE": + self = .elaborate + case "EMOJIFY": + self = .emojify + case "SHORTEN": + self = .shorten + case "FRIENDLY": + self = .friendly + case "PROFESSIONAL": + self = .professional + case "REPHRASE": + self = .rephrase + default: + return nil + } + } + + /** + * Get the String value this NitroRewriteOutputType represents. + */ + var stringValue: String { + switch self { + case .elaborate: + return "ELABORATE" + case .emojify: + return "EMOJIFY" + case .shorten: + return "SHORTEN" + case .friendly: + return "FRIENDLY" + case .professional: + return "PROFESSIONAL" + case .rephrase: + return "REPHRASE" + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteResult.swift new file mode 100644 index 0000000..1b11eb5 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroRewriteResult.swift @@ -0,0 +1,58 @@ +/// +/// NitroRewriteResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroRewriteResult`, backed by a C++ struct. + */ +public typealias NitroRewriteResult = margelo.nitro.ondeviceai.NitroRewriteResult + +public extension NitroRewriteResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroRewriteResult`. + */ + init(rewrittenText: String, style: String, confidence: Double) { + self.init(std.string(rewrittenText), std.string(style), confidence) + } + + var rewrittenText: String { + @inline(__always) + get { + return String(self.__rewrittenText) + } + @inline(__always) + set { + self.__rewrittenText = std.string(newValue) + } + } + + var style: String { + @inline(__always) + get { + return String(self.__style) + } + @inline(__always) + set { + self.__style = std.string(newValue) + } + } + + var confidence: Double { + @inline(__always) + get { + return self.__confidence + } + @inline(__always) + set { + self.__confidence = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeInputType.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeInputType.swift new file mode 100644 index 0000000..92c53c8 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeInputType.swift @@ -0,0 +1,40 @@ +/// +/// NitroSummarizeInputType.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `NitroSummarizeInputType`, backed by a C++ enum. + */ +public typealias NitroSummarizeInputType = margelo.nitro.ondeviceai.NitroSummarizeInputType + +public extension NitroSummarizeInputType { + /** + * Get a NitroSummarizeInputType for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "ARTICLE": + self = .article + case "CONVERSATION": + self = .conversation + default: + return nil + } + } + + /** + * Get the String value this NitroSummarizeInputType represents. + */ + var stringValue: String { + switch self { + case .article: + return "ARTICLE" + case .conversation: + return "CONVERSATION" + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeOptions.swift new file mode 100644 index 0000000..27508ce --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeOptions.swift @@ -0,0 +1,71 @@ +/// +/// NitroSummarizeOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroSummarizeOptions`, backed by a C++ struct. + */ +public typealias NitroSummarizeOptions = margelo.nitro.ondeviceai.NitroSummarizeOptions + +public extension NitroSummarizeOptions { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroSummarizeOptions`. + */ + init(inputType: NitroSummarizeInputType?, outputType: NitroSummarizeOutputType?) { + self.init({ () -> bridge.std__optional_NitroSummarizeInputType_ in + if let __unwrappedValue = inputType { + return bridge.create_std__optional_NitroSummarizeInputType_(__unwrappedValue) + } else { + return .init() + } + }(), { () -> bridge.std__optional_NitroSummarizeOutputType_ in + if let __unwrappedValue = outputType { + return bridge.create_std__optional_NitroSummarizeOutputType_(__unwrappedValue) + } else { + return .init() + } + }()) + } + + var inputType: NitroSummarizeInputType? { + @inline(__always) + get { + return self.__inputType.value + } + @inline(__always) + set { + self.__inputType = { () -> bridge.std__optional_NitroSummarizeInputType_ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_NitroSummarizeInputType_(__unwrappedValue) + } else { + return .init() + } + }() + } + } + + var outputType: NitroSummarizeOutputType? { + @inline(__always) + get { + return self.__outputType.value + } + @inline(__always) + set { + self.__outputType = { () -> bridge.std__optional_NitroSummarizeOutputType_ in + if let __unwrappedValue = newValue { + return bridge.create_std__optional_NitroSummarizeOutputType_(__unwrappedValue) + } else { + return .init() + } + }() + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeOutputType.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeOutputType.swift new file mode 100644 index 0000000..68e8cdd --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeOutputType.swift @@ -0,0 +1,44 @@ +/// +/// NitroSummarizeOutputType.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `NitroSummarizeOutputType`, backed by a C++ enum. + */ +public typealias NitroSummarizeOutputType = margelo.nitro.ondeviceai.NitroSummarizeOutputType + +public extension NitroSummarizeOutputType { + /** + * Get a NitroSummarizeOutputType for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "ONE_BULLET": + self = .oneBullet + case "TWO_BULLETS": + self = .twoBullets + case "THREE_BULLETS": + self = .threeBullets + default: + return nil + } + } + + /** + * Get the String value this NitroSummarizeOutputType represents. + */ + var stringValue: String { + switch self { + case .oneBullet: + return "ONE_BULLET" + case .twoBullets: + return "TWO_BULLETS" + case .threeBullets: + return "THREE_BULLETS" + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeResult.swift new file mode 100644 index 0000000..65dc622 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroSummarizeResult.swift @@ -0,0 +1,69 @@ +/// +/// NitroSummarizeResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroSummarizeResult`, backed by a C++ struct. + */ +public typealias NitroSummarizeResult = margelo.nitro.ondeviceai.NitroSummarizeResult + +public extension NitroSummarizeResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroSummarizeResult`. + */ + init(summary: String, originalLength: Double, summaryLength: Double, confidence: Double) { + self.init(std.string(summary), originalLength, summaryLength, confidence) + } + + var summary: String { + @inline(__always) + get { + return String(self.__summary) + } + @inline(__always) + set { + self.__summary = std.string(newValue) + } + } + + var originalLength: Double { + @inline(__always) + get { + return self.__originalLength + } + @inline(__always) + set { + self.__originalLength = newValue + } + } + + var summaryLength: Double { + @inline(__always) + get { + return self.__summaryLength + } + @inline(__always) + set { + self.__summaryLength = newValue + } + } + + var confidence: Double { + @inline(__always) + get { + return self.__confidence + } + @inline(__always) + set { + self.__confidence = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTextStreamChunk.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTextStreamChunk.swift new file mode 100644 index 0000000..cdbf113 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTextStreamChunk.swift @@ -0,0 +1,58 @@ +/// +/// NitroTextStreamChunk.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroTextStreamChunk`, backed by a C++ struct. + */ +public typealias NitroTextStreamChunk = margelo.nitro.ondeviceai.NitroTextStreamChunk + +public extension NitroTextStreamChunk { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroTextStreamChunk`. + */ + init(delta: String, accumulated: String, isFinal: Bool) { + self.init(std.string(delta), std.string(accumulated), isFinal) + } + + var delta: String { + @inline(__always) + get { + return String(self.__delta) + } + @inline(__always) + set { + self.__delta = std.string(newValue) + } + } + + var accumulated: String { + @inline(__always) + get { + return String(self.__accumulated) + } + @inline(__always) + set { + self.__accumulated = std.string(newValue) + } + } + + var isFinal: Bool { + @inline(__always) + get { + return self.__isFinal + } + @inline(__always) + set { + self.__isFinal = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTranslateOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTranslateOptions.swift new file mode 100644 index 0000000..a7e01ba --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTranslateOptions.swift @@ -0,0 +1,47 @@ +/// +/// NitroTranslateOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroTranslateOptions`, backed by a C++ struct. + */ +public typealias NitroTranslateOptions = margelo.nitro.ondeviceai.NitroTranslateOptions + +public extension NitroTranslateOptions { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroTranslateOptions`. + */ + init(sourceLanguage: String, targetLanguage: String) { + self.init(std.string(sourceLanguage), std.string(targetLanguage)) + } + + var sourceLanguage: String { + @inline(__always) + get { + return String(self.__sourceLanguage) + } + @inline(__always) + set { + self.__sourceLanguage = std.string(newValue) + } + } + + var targetLanguage: String { + @inline(__always) + get { + return String(self.__targetLanguage) + } + @inline(__always) + set { + self.__targetLanguage = std.string(newValue) + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTranslateResult.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTranslateResult.swift new file mode 100644 index 0000000..9273c85 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/NitroTranslateResult.swift @@ -0,0 +1,69 @@ +/// +/// NitroTranslateResult.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import Foundation +import NitroModules + +/** + * Represents an instance of `NitroTranslateResult`, backed by a C++ struct. + */ +public typealias NitroTranslateResult = margelo.nitro.ondeviceai.NitroTranslateResult + +public extension NitroTranslateResult { + private typealias bridge = margelo.nitro.ondeviceai.bridge.swift + + /** + * Create a new instance of `NitroTranslateResult`. + */ + init(translatedText: String, sourceLanguage: String, targetLanguage: String, confidence: Double) { + self.init(std.string(translatedText), std.string(sourceLanguage), std.string(targetLanguage), confidence) + } + + var translatedText: String { + @inline(__always) + get { + return String(self.__translatedText) + } + @inline(__always) + set { + self.__translatedText = std.string(newValue) + } + } + + var sourceLanguage: String { + @inline(__always) + get { + return String(self.__sourceLanguage) + } + @inline(__always) + set { + self.__sourceLanguage = std.string(newValue) + } + } + + var targetLanguage: String { + @inline(__always) + get { + return String(self.__targetLanguage) + } + @inline(__always) + set { + self.__targetLanguage = std.string(newValue) + } + } + + var confidence: Double { + @inline(__always) + get { + return self.__confidence + } + @inline(__always) + set { + self.__confidence = newValue + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/OndeviceAiPlatform.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/OndeviceAiPlatform.swift new file mode 100644 index 0000000..226bf64 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/OndeviceAiPlatform.swift @@ -0,0 +1,40 @@ +/// +/// OndeviceAiPlatform.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `OndeviceAiPlatform`, backed by a C++ enum. + */ +public typealias OndeviceAiPlatform = margelo.nitro.ondeviceai.OndeviceAiPlatform + +public extension OndeviceAiPlatform { + /** + * Get a OndeviceAiPlatform for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "apple": + self = .apple + case "google": + self = .google + default: + return nil + } + } + + /** + * Get the String value this OndeviceAiPlatform represents. + */ + var stringValue: String { + switch self { + case .apple: + return "apple" + case .google: + return "google" + } + } +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_Double.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_Double.swift new file mode 100644 index 0000000..b475940 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_Double.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType_Double.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | number` + */ +@frozen +public enum Variant_NullType_Double { + case first(NullType) + case second(Double) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroChatOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroChatOptions.swift new file mode 100644 index 0000000..b14aa84 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroChatOptions.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType_NitroChatOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | struct` + */ +@frozen +public indirect enum Variant_NullType_NitroChatOptions { + case first(NullType) + case second(NitroChatOptions) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroClassifyOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroClassifyOptions.swift new file mode 100644 index 0000000..f860882 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroClassifyOptions.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType_NitroClassifyOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | struct` + */ +@frozen +public indirect enum Variant_NullType_NitroClassifyOptions { + case first(NullType) + case second(NitroClassifyOptions) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroDescribeImageOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroDescribeImageOptions.swift new file mode 100644 index 0000000..644ef93 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroDescribeImageOptions.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType_NitroDescribeImageOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | struct` + */ +@frozen +public indirect enum Variant_NullType_NitroDescribeImageOptions { + case first(NullType) + case second(NitroDescribeImageOptions) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroExtractOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroExtractOptions.swift new file mode 100644 index 0000000..24bf74e --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroExtractOptions.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType_NitroExtractOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | struct` + */ +@frozen +public indirect enum Variant_NullType_NitroExtractOptions { + case first(NullType) + case second(NitroExtractOptions) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroSummarizeOptions.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroSummarizeOptions.swift new file mode 100644 index 0000000..443cc9d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_NitroSummarizeOptions.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType_NitroSummarizeOptions.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | struct` + */ +@frozen +public indirect enum Variant_NullType_NitroSummarizeOptions { + case first(NullType) + case second(NitroSummarizeOptions) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_String.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_String.swift new file mode 100644 index 0000000..3993805 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType_String.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType_String.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | string` + */ +@frozen +public enum Variant_NullType_String { + case first(NullType) + case second(String) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType__NitroChatMessage_.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType__NitroChatMessage_.swift new file mode 100644 index 0000000..69706f1 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType__NitroChatMessage_.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType__NitroChatMessage_.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | array` + */ +@frozen +public indirect enum Variant_NullType__NitroChatMessage_ { + case first(NullType) + case second([NitroChatMessage]) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType__String_.swift b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType__String_.swift new file mode 100644 index 0000000..00b6ca2 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/ios/swift/Variant_NullType__String_.swift @@ -0,0 +1,18 @@ +/// +/// Variant_NullType__String_.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +import NitroModules + +/** + * An Swift enum with associated values representing a Variant/Union type. + * JS type: `null | array` + */ +@frozen +public indirect enum Variant_NullType__String_ { + case first(NullType) + case second([String]) +} diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/HybridOndeviceAiSpec.cpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/HybridOndeviceAiSpec.cpp new file mode 100644 index 0000000..954f22d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/HybridOndeviceAiSpec.cpp @@ -0,0 +1,53 @@ +/// +/// HybridOndeviceAiSpec.cpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#include "HybridOndeviceAiSpec.hpp" + +namespace margelo::nitro::ondeviceai { + + void HybridOndeviceAiSpec::loadHybridMethods() { + // load base methods/properties + HybridObject::loadHybridMethods(); + // load custom methods/properties + registerHybrids(this, [](Prototype& prototype) { + prototype.registerHybridMethod("initialize", &HybridOndeviceAiSpec::initialize); + prototype.registerHybridMethod("getDeviceCapability", &HybridOndeviceAiSpec::getDeviceCapability); + prototype.registerHybridMethod("summarize", &HybridOndeviceAiSpec::summarize); + prototype.registerHybridMethod("classify", &HybridOndeviceAiSpec::classify); + prototype.registerHybridMethod("extract", &HybridOndeviceAiSpec::extract); + prototype.registerHybridMethod("chat", &HybridOndeviceAiSpec::chat); + prototype.registerHybridMethod("translate", &HybridOndeviceAiSpec::translate); + prototype.registerHybridMethod("rewrite", &HybridOndeviceAiSpec::rewrite); + prototype.registerHybridMethod("proofread", &HybridOndeviceAiSpec::proofread); + prototype.registerHybridMethod("chatStream", &HybridOndeviceAiSpec::chatStream); + prototype.registerHybridMethod("addChatStreamListener", &HybridOndeviceAiSpec::addChatStreamListener); + prototype.registerHybridMethod("removeChatStreamListener", &HybridOndeviceAiSpec::removeChatStreamListener); + prototype.registerHybridMethod("summarizeStreaming", &HybridOndeviceAiSpec::summarizeStreaming); + prototype.registerHybridMethod("addSummarizeStreamListener", &HybridOndeviceAiSpec::addSummarizeStreamListener); + prototype.registerHybridMethod("removeSummarizeStreamListener", &HybridOndeviceAiSpec::removeSummarizeStreamListener); + prototype.registerHybridMethod("translateStreaming", &HybridOndeviceAiSpec::translateStreaming); + prototype.registerHybridMethod("addTranslateStreamListener", &HybridOndeviceAiSpec::addTranslateStreamListener); + prototype.registerHybridMethod("removeTranslateStreamListener", &HybridOndeviceAiSpec::removeTranslateStreamListener); + prototype.registerHybridMethod("rewriteStreaming", &HybridOndeviceAiSpec::rewriteStreaming); + prototype.registerHybridMethod("addRewriteStreamListener", &HybridOndeviceAiSpec::addRewriteStreamListener); + prototype.registerHybridMethod("removeRewriteStreamListener", &HybridOndeviceAiSpec::removeRewriteStreamListener); + prototype.registerHybridMethod("describeImage", &HybridOndeviceAiSpec::describeImage); + prototype.registerHybridMethod("getAvailableModels", &HybridOndeviceAiSpec::getAvailableModels); + prototype.registerHybridMethod("getDownloadedModels", &HybridOndeviceAiSpec::getDownloadedModels); + prototype.registerHybridMethod("getLoadedModel", &HybridOndeviceAiSpec::getLoadedModel); + prototype.registerHybridMethod("getCurrentEngine", &HybridOndeviceAiSpec::getCurrentEngine); + prototype.registerHybridMethod("downloadModel", &HybridOndeviceAiSpec::downloadModel); + prototype.registerHybridMethod("addModelDownloadProgressListener", &HybridOndeviceAiSpec::addModelDownloadProgressListener); + prototype.registerHybridMethod("removeModelDownloadProgressListener", &HybridOndeviceAiSpec::removeModelDownloadProgressListener); + prototype.registerHybridMethod("loadModel", &HybridOndeviceAiSpec::loadModel); + prototype.registerHybridMethod("deleteModel", &HybridOndeviceAiSpec::deleteModel); + prototype.registerHybridMethod("getPromptApiStatus", &HybridOndeviceAiSpec::getPromptApiStatus); + prototype.registerHybridMethod("downloadPromptApiModel", &HybridOndeviceAiSpec::downloadPromptApiModel); + }); + } + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/HybridOndeviceAiSpec.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/HybridOndeviceAiSpec.hpp new file mode 100644 index 0000000..cd5853e --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/HybridOndeviceAiSpec.hpp @@ -0,0 +1,162 @@ +/// +/// HybridOndeviceAiSpec.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroDeviceCapability` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDeviceCapability; } +// Forward declaration of `NitroSummarizeResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeResult; } +// Forward declaration of `NitroSummarizeOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroSummarizeOptions; } +// Forward declaration of `NitroClassifyResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyResult; } +// Forward declaration of `NitroClassifyOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassifyOptions; } +// Forward declaration of `NitroExtractResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractResult; } +// Forward declaration of `NitroExtractOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractOptions; } +// Forward declaration of `NitroChatResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatResult; } +// Forward declaration of `NitroChatOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatOptions; } +// Forward declaration of `NitroTranslateResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateResult; } +// Forward declaration of `NitroTranslateOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTranslateOptions; } +// Forward declaration of `NitroRewriteResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteResult; } +// Forward declaration of `NitroRewriteOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroRewriteOptions; } +// Forward declaration of `NitroProofreadResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadResult; } +// Forward declaration of `NitroChatStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatStreamChunk; } +// Forward declaration of `NitroTextStreamChunk` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroTextStreamChunk; } +// Forward declaration of `NitroDescribeImageResult` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageResult; } +// Forward declaration of `NitroDescribeImageOptions` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroDescribeImageOptions; } +// Forward declaration of `NitroModelInfo` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelInfo; } +// Forward declaration of `NitroInferenceEngine` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroInferenceEngine; } +// Forward declaration of `NitroModelDownloadProgress` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroModelDownloadProgress; } + +#include +#include "NitroDeviceCapability.hpp" +#include "NitroSummarizeResult.hpp" +#include +#include +#include "NitroSummarizeOptions.hpp" +#include +#include +#include "NitroClassifyResult.hpp" +#include "NitroClassifyOptions.hpp" +#include "NitroExtractResult.hpp" +#include "NitroExtractOptions.hpp" +#include "NitroChatResult.hpp" +#include "NitroChatOptions.hpp" +#include "NitroTranslateResult.hpp" +#include "NitroTranslateOptions.hpp" +#include "NitroRewriteResult.hpp" +#include "NitroRewriteOptions.hpp" +#include "NitroProofreadResult.hpp" +#include "NitroChatStreamChunk.hpp" +#include +#include "NitroTextStreamChunk.hpp" +#include "NitroDescribeImageResult.hpp" +#include "NitroDescribeImageOptions.hpp" +#include "NitroModelInfo.hpp" +#include +#include "NitroInferenceEngine.hpp" +#include "NitroModelDownloadProgress.hpp" + +namespace margelo::nitro::ondeviceai { + + using namespace margelo::nitro; + + /** + * An abstract base class for `OndeviceAi` + * Inherit this class to create instances of `HybridOndeviceAiSpec` in C++. + * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual. + * @example + * ```cpp + * class HybridOndeviceAi: public HybridOndeviceAiSpec { + * public: + * HybridOndeviceAi(...): HybridObject(TAG) { ... } + * // ... + * }; + * ``` + */ + class HybridOndeviceAiSpec: public virtual HybridObject { + public: + // Constructor + explicit HybridOndeviceAiSpec(): HybridObject(TAG) { } + + // Destructor + ~HybridOndeviceAiSpec() override = default; + + public: + // Properties + + + public: + // Methods + virtual std::shared_ptr> initialize() = 0; + virtual std::shared_ptr> getDeviceCapability() = 0; + virtual std::shared_ptr> summarize(const std::string& text, const std::optional>& options) = 0; + virtual std::shared_ptr> classify(const std::string& text, const std::optional>& options) = 0; + virtual std::shared_ptr> extract(const std::string& text, const std::optional>& options) = 0; + virtual std::shared_ptr> chat(const std::string& message, const std::optional>& options) = 0; + virtual std::shared_ptr> translate(const std::string& text, const NitroTranslateOptions& options) = 0; + virtual std::shared_ptr> rewrite(const std::string& text, const NitroRewriteOptions& options) = 0; + virtual std::shared_ptr> proofread(const std::string& text) = 0; + virtual std::shared_ptr> chatStream(const std::string& message, const std::optional>& options) = 0; + virtual void addChatStreamListener(const std::function& listener) = 0; + virtual void removeChatStreamListener(const std::function& listener) = 0; + virtual std::shared_ptr> summarizeStreaming(const std::string& text, const std::optional>& options) = 0; + virtual void addSummarizeStreamListener(const std::function& listener) = 0; + virtual void removeSummarizeStreamListener(const std::function& listener) = 0; + virtual std::shared_ptr> translateStreaming(const std::string& text, const NitroTranslateOptions& options) = 0; + virtual void addTranslateStreamListener(const std::function& listener) = 0; + virtual void removeTranslateStreamListener(const std::function& listener) = 0; + virtual std::shared_ptr> rewriteStreaming(const std::string& text, const NitroRewriteOptions& options) = 0; + virtual void addRewriteStreamListener(const std::function& listener) = 0; + virtual void removeRewriteStreamListener(const std::function& listener) = 0; + virtual std::shared_ptr> describeImage(const std::string& imageUri, const std::optional>& options) = 0; + virtual std::shared_ptr>> getAvailableModels() = 0; + virtual std::shared_ptr>> getDownloadedModels() = 0; + virtual std::shared_ptr> getLoadedModel() = 0; + virtual std::shared_ptr> getCurrentEngine() = 0; + virtual std::shared_ptr> downloadModel(const std::string& modelId) = 0; + virtual void addModelDownloadProgressListener(const std::function& listener) = 0; + virtual void removeModelDownloadProgressListener(const std::function& listener) = 0; + virtual std::shared_ptr> loadModel(const std::string& modelId) = 0; + virtual std::shared_ptr> deleteModel(const std::string& modelId) = 0; + virtual std::shared_ptr> getPromptApiStatus() = 0; + virtual std::shared_ptr> downloadPromptApiModel() = 0; + + protected: + // Hybrid Setup + void loadHybridMethods() override; + + protected: + // Tag for logging + static constexpr auto TAG = "OndeviceAi"; + }; + +} // namespace margelo::nitro::ondeviceai diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatMessage.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatMessage.hpp new file mode 100644 index 0000000..8d53638 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatMessage.hpp @@ -0,0 +1,81 @@ +/// +/// NitroChatMessage.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroChatMessageRole` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroChatMessageRole; } + +#include "NitroChatMessageRole.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroChatMessage). + */ + struct NitroChatMessage { + public: + NitroChatMessageRole role SWIFT_PRIVATE; + std::string content SWIFT_PRIVATE; + + public: + NitroChatMessage() = default; + explicit NitroChatMessage(NitroChatMessageRole role, std::string content): role(role), content(content) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroChatMessage <> JS NitroChatMessage (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroChatMessage fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroChatMessage( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "role")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "content")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroChatMessage& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "role", JSIConverter::toJSI(runtime, arg.role)); + obj.setProperty(runtime, "content", JSIConverter::toJSI(runtime, arg.content)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "role"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "content"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatMessageRole.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatMessageRole.hpp new file mode 100644 index 0000000..21fd707 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatMessageRole.hpp @@ -0,0 +1,80 @@ +/// +/// NitroChatMessageRole.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::ondeviceai { + + /** + * An enum which can be represented as a JavaScript union (NitroChatMessageRole). + */ + enum class NitroChatMessageRole { + USER SWIFT_NAME(user) = 0, + ASSISTANT SWIFT_NAME(assistant) = 1, + SYSTEM SWIFT_NAME(system) = 2, + } CLOSED_ENUM; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroChatMessageRole <> JS NitroChatMessageRole (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroChatMessageRole fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("user"): return margelo::nitro::ondeviceai::NitroChatMessageRole::USER; + case hashString("assistant"): return margelo::nitro::ondeviceai::NitroChatMessageRole::ASSISTANT; + case hashString("system"): return margelo::nitro::ondeviceai::NitroChatMessageRole::SYSTEM; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NitroChatMessageRole - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ondeviceai::NitroChatMessageRole arg) { + switch (arg) { + case margelo::nitro::ondeviceai::NitroChatMessageRole::USER: return JSIConverter::toJSI(runtime, "user"); + case margelo::nitro::ondeviceai::NitroChatMessageRole::ASSISTANT: return JSIConverter::toJSI(runtime, "assistant"); + case margelo::nitro::ondeviceai::NitroChatMessageRole::SYSTEM: return JSIConverter::toJSI(runtime, "system"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert NitroChatMessageRole to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("user"): + case hashString("assistant"): + case hashString("system"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatOptions.hpp new file mode 100644 index 0000000..5c82463 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatOptions.hpp @@ -0,0 +1,85 @@ +/// +/// NitroChatOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroChatMessage` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroChatMessage; } + +#include +#include +#include +#include +#include "NitroChatMessage.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroChatOptions). + */ + struct NitroChatOptions { + public: + std::optional> systemPrompt SWIFT_PRIVATE; + std::optional>> history SWIFT_PRIVATE; + + public: + NitroChatOptions() = default; + explicit NitroChatOptions(std::optional> systemPrompt, std::optional>> history): systemPrompt(systemPrompt), history(history) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroChatOptions <> JS NitroChatOptions (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroChatOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroChatOptions( + JSIConverter>>::fromJSI(runtime, obj.getProperty(runtime, "systemPrompt")), + JSIConverter>>>::fromJSI(runtime, obj.getProperty(runtime, "history")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroChatOptions& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "systemPrompt", JSIConverter>>::toJSI(runtime, arg.systemPrompt)); + obj.setProperty(runtime, "history", JSIConverter>>>::toJSI(runtime, arg.history)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>>::canConvert(runtime, obj.getProperty(runtime, "systemPrompt"))) return false; + if (!JSIConverter>>>::canConvert(runtime, obj.getProperty(runtime, "history"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatResult.hpp new file mode 100644 index 0000000..2749076 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatResult.hpp @@ -0,0 +1,83 @@ +/// +/// NitroChatResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroChatResult). + */ + struct NitroChatResult { + public: + std::string message SWIFT_PRIVATE; + std::string conversationId SWIFT_PRIVATE; + bool canContinue SWIFT_PRIVATE; + + public: + NitroChatResult() = default; + explicit NitroChatResult(std::string message, std::string conversationId, bool canContinue): message(message), conversationId(conversationId), canContinue(canContinue) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroChatResult <> JS NitroChatResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroChatResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroChatResult( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "message")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "conversationId")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "canContinue")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroChatResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "message", JSIConverter::toJSI(runtime, arg.message)); + obj.setProperty(runtime, "conversationId", JSIConverter::toJSI(runtime, arg.conversationId)); + obj.setProperty(runtime, "canContinue", JSIConverter::toJSI(runtime, arg.canContinue)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "message"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "conversationId"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "canContinue"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatStreamChunk.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatStreamChunk.hpp new file mode 100644 index 0000000..df4d72c --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroChatStreamChunk.hpp @@ -0,0 +1,83 @@ +/// +/// NitroChatStreamChunk.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroChatStreamChunk). + */ + struct NitroChatStreamChunk { + public: + std::string delta SWIFT_PRIVATE; + std::string accumulated SWIFT_PRIVATE; + bool isFinal SWIFT_PRIVATE; + + public: + NitroChatStreamChunk() = default; + explicit NitroChatStreamChunk(std::string delta, std::string accumulated, bool isFinal): delta(delta), accumulated(accumulated), isFinal(isFinal) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroChatStreamChunk <> JS NitroChatStreamChunk (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroChatStreamChunk fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroChatStreamChunk( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "delta")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "accumulated")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "isFinal")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroChatStreamChunk& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "delta", JSIConverter::toJSI(runtime, arg.delta)); + obj.setProperty(runtime, "accumulated", JSIConverter::toJSI(runtime, arg.accumulated)); + obj.setProperty(runtime, "isFinal", JSIConverter::toJSI(runtime, arg.isFinal)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "delta"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "accumulated"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "isFinal"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassification.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassification.hpp new file mode 100644 index 0000000..c16c703 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassification.hpp @@ -0,0 +1,83 @@ +/// +/// NitroClassification.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroClassification). + */ + struct NitroClassification { + public: + std::string label SWIFT_PRIVATE; + double score SWIFT_PRIVATE; + std::string metadata SWIFT_PRIVATE; + + public: + NitroClassification() = default; + explicit NitroClassification(std::string label, double score, std::string metadata): label(label), score(score), metadata(metadata) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroClassification <> JS NitroClassification (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroClassification fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroClassification( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "label")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "score")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "metadata")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroClassification& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "label", JSIConverter::toJSI(runtime, arg.label)); + obj.setProperty(runtime, "score", JSIConverter::toJSI(runtime, arg.score)); + obj.setProperty(runtime, "metadata", JSIConverter::toJSI(runtime, arg.metadata)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "label"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "score"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "metadata"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassifyOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassifyOptions.hpp new file mode 100644 index 0000000..c4be1d9 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassifyOptions.hpp @@ -0,0 +1,83 @@ +/// +/// NitroClassifyOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroClassifyOptions). + */ + struct NitroClassifyOptions { + public: + std::optional>> categories SWIFT_PRIVATE; + std::optional> maxResults SWIFT_PRIVATE; + + public: + NitroClassifyOptions() = default; + explicit NitroClassifyOptions(std::optional>> categories, std::optional> maxResults): categories(categories), maxResults(maxResults) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroClassifyOptions <> JS NitroClassifyOptions (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroClassifyOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroClassifyOptions( + JSIConverter>>>::fromJSI(runtime, obj.getProperty(runtime, "categories")), + JSIConverter>>::fromJSI(runtime, obj.getProperty(runtime, "maxResults")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroClassifyOptions& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "categories", JSIConverter>>>::toJSI(runtime, arg.categories)); + obj.setProperty(runtime, "maxResults", JSIConverter>>::toJSI(runtime, arg.maxResults)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>>>::canConvert(runtime, obj.getProperty(runtime, "categories"))) return false; + if (!JSIConverter>>::canConvert(runtime, obj.getProperty(runtime, "maxResults"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassifyResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassifyResult.hpp new file mode 100644 index 0000000..d1b7fb6 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroClassifyResult.hpp @@ -0,0 +1,86 @@ +/// +/// NitroClassifyResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroClassification` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroClassification; } + +#include "NitroClassification.hpp" +#include +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroClassifyResult). + */ + struct NitroClassifyResult { + public: + std::vector classifications SWIFT_PRIVATE; + std::string topLabel SWIFT_PRIVATE; + double topScore SWIFT_PRIVATE; + + public: + NitroClassifyResult() = default; + explicit NitroClassifyResult(std::vector classifications, std::string topLabel, double topScore): classifications(classifications), topLabel(topLabel), topScore(topScore) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroClassifyResult <> JS NitroClassifyResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroClassifyResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroClassifyResult( + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "classifications")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "topLabel")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "topScore")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroClassifyResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "classifications", JSIConverter>::toJSI(runtime, arg.classifications)); + obj.setProperty(runtime, "topLabel", JSIConverter::toJSI(runtime, arg.topLabel)); + obj.setProperty(runtime, "topScore", JSIConverter::toJSI(runtime, arg.topScore)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "classifications"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "topLabel"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "topScore"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDescribeImageOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDescribeImageOptions.hpp new file mode 100644 index 0000000..d39cb27 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDescribeImageOptions.hpp @@ -0,0 +1,78 @@ +/// +/// NitroDescribeImageOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroDescribeImageOptions). + */ + struct NitroDescribeImageOptions { + public: + std::optional> prompt SWIFT_PRIVATE; + + public: + NitroDescribeImageOptions() = default; + explicit NitroDescribeImageOptions(std::optional> prompt): prompt(prompt) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroDescribeImageOptions <> JS NitroDescribeImageOptions (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroDescribeImageOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroDescribeImageOptions( + JSIConverter>>::fromJSI(runtime, obj.getProperty(runtime, "prompt")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroDescribeImageOptions& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "prompt", JSIConverter>>::toJSI(runtime, arg.prompt)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>>::canConvert(runtime, obj.getProperty(runtime, "prompt"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDescribeImageResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDescribeImageResult.hpp new file mode 100644 index 0000000..e74f871 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDescribeImageResult.hpp @@ -0,0 +1,79 @@ +/// +/// NitroDescribeImageResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroDescribeImageResult). + */ + struct NitroDescribeImageResult { + public: + std::string description SWIFT_PRIVATE; + double confidence SWIFT_PRIVATE; + + public: + NitroDescribeImageResult() = default; + explicit NitroDescribeImageResult(std::string description, double confidence): description(description), confidence(confidence) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroDescribeImageResult <> JS NitroDescribeImageResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroDescribeImageResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroDescribeImageResult( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "description")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "confidence")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroDescribeImageResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "description", JSIConverter::toJSI(runtime, arg.description)); + obj.setProperty(runtime, "confidence", JSIConverter::toJSI(runtime, arg.confidence)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "description"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "confidence"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDeviceCapability.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDeviceCapability.hpp new file mode 100644 index 0000000..b4f2343 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroDeviceCapability.hpp @@ -0,0 +1,124 @@ +/// +/// NitroDeviceCapability.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `OndeviceAiPlatform` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class OndeviceAiPlatform; } + +#include "OndeviceAiPlatform.hpp" + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroDeviceCapability). + */ + struct NitroDeviceCapability { + public: + bool isSupported SWIFT_PRIVATE; + bool isModelReady SWIFT_PRIVATE; + bool supportsAppleIntelligence SWIFT_PRIVATE; + OndeviceAiPlatform platform SWIFT_PRIVATE; + bool featureSummarize SWIFT_PRIVATE; + bool featureClassify SWIFT_PRIVATE; + bool featureExtract SWIFT_PRIVATE; + bool featureChat SWIFT_PRIVATE; + bool featureTranslate SWIFT_PRIVATE; + bool featureRewrite SWIFT_PRIVATE; + bool featureProofread SWIFT_PRIVATE; + double availableMemoryMB SWIFT_PRIVATE; + bool isLowPowerMode SWIFT_PRIVATE; + + public: + NitroDeviceCapability() = default; + explicit NitroDeviceCapability(bool isSupported, bool isModelReady, bool supportsAppleIntelligence, OndeviceAiPlatform platform, bool featureSummarize, bool featureClassify, bool featureExtract, bool featureChat, bool featureTranslate, bool featureRewrite, bool featureProofread, double availableMemoryMB, bool isLowPowerMode): isSupported(isSupported), isModelReady(isModelReady), supportsAppleIntelligence(supportsAppleIntelligence), platform(platform), featureSummarize(featureSummarize), featureClassify(featureClassify), featureExtract(featureExtract), featureChat(featureChat), featureTranslate(featureTranslate), featureRewrite(featureRewrite), featureProofread(featureProofread), availableMemoryMB(availableMemoryMB), isLowPowerMode(isLowPowerMode) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroDeviceCapability <> JS NitroDeviceCapability (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroDeviceCapability fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroDeviceCapability( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "isSupported")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "isModelReady")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "supportsAppleIntelligence")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "platform")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "featureSummarize")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "featureClassify")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "featureExtract")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "featureChat")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "featureTranslate")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "featureRewrite")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "featureProofread")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "availableMemoryMB")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "isLowPowerMode")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroDeviceCapability& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "isSupported", JSIConverter::toJSI(runtime, arg.isSupported)); + obj.setProperty(runtime, "isModelReady", JSIConverter::toJSI(runtime, arg.isModelReady)); + obj.setProperty(runtime, "supportsAppleIntelligence", JSIConverter::toJSI(runtime, arg.supportsAppleIntelligence)); + obj.setProperty(runtime, "platform", JSIConverter::toJSI(runtime, arg.platform)); + obj.setProperty(runtime, "featureSummarize", JSIConverter::toJSI(runtime, arg.featureSummarize)); + obj.setProperty(runtime, "featureClassify", JSIConverter::toJSI(runtime, arg.featureClassify)); + obj.setProperty(runtime, "featureExtract", JSIConverter::toJSI(runtime, arg.featureExtract)); + obj.setProperty(runtime, "featureChat", JSIConverter::toJSI(runtime, arg.featureChat)); + obj.setProperty(runtime, "featureTranslate", JSIConverter::toJSI(runtime, arg.featureTranslate)); + obj.setProperty(runtime, "featureRewrite", JSIConverter::toJSI(runtime, arg.featureRewrite)); + obj.setProperty(runtime, "featureProofread", JSIConverter::toJSI(runtime, arg.featureProofread)); + obj.setProperty(runtime, "availableMemoryMB", JSIConverter::toJSI(runtime, arg.availableMemoryMB)); + obj.setProperty(runtime, "isLowPowerMode", JSIConverter::toJSI(runtime, arg.isLowPowerMode)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "isSupported"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "isModelReady"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "supportsAppleIntelligence"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "platform"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "featureSummarize"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "featureClassify"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "featureExtract"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "featureChat"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "featureTranslate"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "featureRewrite"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "featureProofread"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "availableMemoryMB"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "isLowPowerMode"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractEntity.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractEntity.hpp new file mode 100644 index 0000000..bc12b59 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractEntity.hpp @@ -0,0 +1,91 @@ +/// +/// NitroExtractEntity.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroExtractEntity). + */ + struct NitroExtractEntity { + public: + std::string type SWIFT_PRIVATE; + std::string value SWIFT_PRIVATE; + double confidence SWIFT_PRIVATE; + double startPos SWIFT_PRIVATE; + double endPos SWIFT_PRIVATE; + + public: + NitroExtractEntity() = default; + explicit NitroExtractEntity(std::string type, std::string value, double confidence, double startPos, double endPos): type(type), value(value), confidence(confidence), startPos(startPos), endPos(endPos) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroExtractEntity <> JS NitroExtractEntity (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroExtractEntity fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroExtractEntity( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "type")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "value")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "confidence")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "startPos")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "endPos")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroExtractEntity& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "type", JSIConverter::toJSI(runtime, arg.type)); + obj.setProperty(runtime, "value", JSIConverter::toJSI(runtime, arg.value)); + obj.setProperty(runtime, "confidence", JSIConverter::toJSI(runtime, arg.confidence)); + obj.setProperty(runtime, "startPos", JSIConverter::toJSI(runtime, arg.startPos)); + obj.setProperty(runtime, "endPos", JSIConverter::toJSI(runtime, arg.endPos)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "type"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "value"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "confidence"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "startPos"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "endPos"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractOptions.hpp new file mode 100644 index 0000000..5b92518 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractOptions.hpp @@ -0,0 +1,79 @@ +/// +/// NitroExtractOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include +#include +#include +#include +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroExtractOptions). + */ + struct NitroExtractOptions { + public: + std::optional>> entityTypes SWIFT_PRIVATE; + + public: + NitroExtractOptions() = default; + explicit NitroExtractOptions(std::optional>> entityTypes): entityTypes(entityTypes) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroExtractOptions <> JS NitroExtractOptions (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroExtractOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroExtractOptions( + JSIConverter>>>::fromJSI(runtime, obj.getProperty(runtime, "entityTypes")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroExtractOptions& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "entityTypes", JSIConverter>>>::toJSI(runtime, arg.entityTypes)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>>>::canConvert(runtime, obj.getProperty(runtime, "entityTypes"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractResult.hpp new file mode 100644 index 0000000..0f14991 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroExtractResult.hpp @@ -0,0 +1,77 @@ +/// +/// NitroExtractResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroExtractEntity` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroExtractEntity; } + +#include "NitroExtractEntity.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroExtractResult). + */ + struct NitroExtractResult { + public: + std::vector entities SWIFT_PRIVATE; + + public: + NitroExtractResult() = default; + explicit NitroExtractResult(std::vector entities): entities(entities) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroExtractResult <> JS NitroExtractResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroExtractResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroExtractResult( + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "entities")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroExtractResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "entities", JSIConverter>::toJSI(runtime, arg.entities)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "entities"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroInferenceEngine.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroInferenceEngine.hpp new file mode 100644 index 0000000..8de2d11 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroInferenceEngine.hpp @@ -0,0 +1,92 @@ +/// +/// NitroInferenceEngine.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::ondeviceai { + + /** + * An enum which can be represented as a JavaScript union (NitroInferenceEngine). + */ + enum class NitroInferenceEngine { + FOUNDATION_MODELS SWIFT_NAME(foundationModels) = 0, + LLAMA_CPP SWIFT_NAME(llamaCpp) = 1, + MLX SWIFT_NAME(mlx) = 2, + CORE_ML SWIFT_NAME(coreMl) = 3, + PROMPT_API SWIFT_NAME(promptApi) = 4, + NONE SWIFT_NAME(none) = 5, + } CLOSED_ENUM; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroInferenceEngine <> JS NitroInferenceEngine (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroInferenceEngine fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("foundation_models"): return margelo::nitro::ondeviceai::NitroInferenceEngine::FOUNDATION_MODELS; + case hashString("llama_cpp"): return margelo::nitro::ondeviceai::NitroInferenceEngine::LLAMA_CPP; + case hashString("mlx"): return margelo::nitro::ondeviceai::NitroInferenceEngine::MLX; + case hashString("core_ml"): return margelo::nitro::ondeviceai::NitroInferenceEngine::CORE_ML; + case hashString("prompt_api"): return margelo::nitro::ondeviceai::NitroInferenceEngine::PROMPT_API; + case hashString("none"): return margelo::nitro::ondeviceai::NitroInferenceEngine::NONE; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NitroInferenceEngine - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ondeviceai::NitroInferenceEngine arg) { + switch (arg) { + case margelo::nitro::ondeviceai::NitroInferenceEngine::FOUNDATION_MODELS: return JSIConverter::toJSI(runtime, "foundation_models"); + case margelo::nitro::ondeviceai::NitroInferenceEngine::LLAMA_CPP: return JSIConverter::toJSI(runtime, "llama_cpp"); + case margelo::nitro::ondeviceai::NitroInferenceEngine::MLX: return JSIConverter::toJSI(runtime, "mlx"); + case margelo::nitro::ondeviceai::NitroInferenceEngine::CORE_ML: return JSIConverter::toJSI(runtime, "core_ml"); + case margelo::nitro::ondeviceai::NitroInferenceEngine::PROMPT_API: return JSIConverter::toJSI(runtime, "prompt_api"); + case margelo::nitro::ondeviceai::NitroInferenceEngine::NONE: return JSIConverter::toJSI(runtime, "none"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert NitroInferenceEngine to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("foundation_models"): + case hashString("llama_cpp"): + case hashString("mlx"): + case hashString("core_ml"): + case hashString("prompt_api"): + case hashString("none"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelDownloadProgress.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelDownloadProgress.hpp new file mode 100644 index 0000000..115491e --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelDownloadProgress.hpp @@ -0,0 +1,93 @@ +/// +/// NitroModelDownloadProgress.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroModelDownloadState` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroModelDownloadState; } + +#include +#include "NitroModelDownloadState.hpp" + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroModelDownloadProgress). + */ + struct NitroModelDownloadProgress { + public: + std::string modelId SWIFT_PRIVATE; + double bytesDownloaded SWIFT_PRIVATE; + double totalBytes SWIFT_PRIVATE; + double progress SWIFT_PRIVATE; + NitroModelDownloadState state SWIFT_PRIVATE; + + public: + NitroModelDownloadProgress() = default; + explicit NitroModelDownloadProgress(std::string modelId, double bytesDownloaded, double totalBytes, double progress, NitroModelDownloadState state): modelId(modelId), bytesDownloaded(bytesDownloaded), totalBytes(totalBytes), progress(progress), state(state) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroModelDownloadProgress <> JS NitroModelDownloadProgress (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroModelDownloadProgress fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroModelDownloadProgress( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "modelId")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "bytesDownloaded")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "totalBytes")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "progress")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "state")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroModelDownloadProgress& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "modelId", JSIConverter::toJSI(runtime, arg.modelId)); + obj.setProperty(runtime, "bytesDownloaded", JSIConverter::toJSI(runtime, arg.bytesDownloaded)); + obj.setProperty(runtime, "totalBytes", JSIConverter::toJSI(runtime, arg.totalBytes)); + obj.setProperty(runtime, "progress", JSIConverter::toJSI(runtime, arg.progress)); + obj.setProperty(runtime, "state", JSIConverter::toJSI(runtime, arg.state)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "modelId"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "bytesDownloaded"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "totalBytes"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "progress"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "state"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelDownloadState.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelDownloadState.hpp new file mode 100644 index 0000000..f995158 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelDownloadState.hpp @@ -0,0 +1,92 @@ +/// +/// NitroModelDownloadState.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::ondeviceai { + + /** + * An enum which can be represented as a JavaScript union (NitroModelDownloadState). + */ + enum class NitroModelDownloadState { + PENDING SWIFT_NAME(pending) = 0, + DOWNLOADING SWIFT_NAME(downloading) = 1, + VERIFYING SWIFT_NAME(verifying) = 2, + COMPLETED SWIFT_NAME(completed) = 3, + FAILED SWIFT_NAME(failed) = 4, + CANCELLED SWIFT_NAME(cancelled) = 5, + } CLOSED_ENUM; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroModelDownloadState <> JS NitroModelDownloadState (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroModelDownloadState fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("pending"): return margelo::nitro::ondeviceai::NitroModelDownloadState::PENDING; + case hashString("downloading"): return margelo::nitro::ondeviceai::NitroModelDownloadState::DOWNLOADING; + case hashString("verifying"): return margelo::nitro::ondeviceai::NitroModelDownloadState::VERIFYING; + case hashString("completed"): return margelo::nitro::ondeviceai::NitroModelDownloadState::COMPLETED; + case hashString("failed"): return margelo::nitro::ondeviceai::NitroModelDownloadState::FAILED; + case hashString("cancelled"): return margelo::nitro::ondeviceai::NitroModelDownloadState::CANCELLED; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NitroModelDownloadState - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ondeviceai::NitroModelDownloadState arg) { + switch (arg) { + case margelo::nitro::ondeviceai::NitroModelDownloadState::PENDING: return JSIConverter::toJSI(runtime, "pending"); + case margelo::nitro::ondeviceai::NitroModelDownloadState::DOWNLOADING: return JSIConverter::toJSI(runtime, "downloading"); + case margelo::nitro::ondeviceai::NitroModelDownloadState::VERIFYING: return JSIConverter::toJSI(runtime, "verifying"); + case margelo::nitro::ondeviceai::NitroModelDownloadState::COMPLETED: return JSIConverter::toJSI(runtime, "completed"); + case margelo::nitro::ondeviceai::NitroModelDownloadState::FAILED: return JSIConverter::toJSI(runtime, "failed"); + case margelo::nitro::ondeviceai::NitroModelDownloadState::CANCELLED: return JSIConverter::toJSI(runtime, "cancelled"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert NitroModelDownloadState to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("pending"): + case hashString("downloading"): + case hashString("verifying"): + case hashString("completed"): + case hashString("failed"): + case hashString("cancelled"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelInfo.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelInfo.hpp new file mode 100644 index 0000000..778691a --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroModelInfo.hpp @@ -0,0 +1,103 @@ +/// +/// NitroModelInfo.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroModelInfo). + */ + struct NitroModelInfo { + public: + std::string modelId SWIFT_PRIVATE; + std::string name SWIFT_PRIVATE; + std::string version SWIFT_PRIVATE; + double sizeMB SWIFT_PRIVATE; + std::string quantization SWIFT_PRIVATE; + double contextLength SWIFT_PRIVATE; + double minMemoryMB SWIFT_PRIVATE; + bool isMultimodal SWIFT_PRIVATE; + + public: + NitroModelInfo() = default; + explicit NitroModelInfo(std::string modelId, std::string name, std::string version, double sizeMB, std::string quantization, double contextLength, double minMemoryMB, bool isMultimodal): modelId(modelId), name(name), version(version), sizeMB(sizeMB), quantization(quantization), contextLength(contextLength), minMemoryMB(minMemoryMB), isMultimodal(isMultimodal) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroModelInfo <> JS NitroModelInfo (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroModelInfo fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroModelInfo( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "modelId")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "name")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "version")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "sizeMB")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "quantization")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "contextLength")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "minMemoryMB")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "isMultimodal")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroModelInfo& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "modelId", JSIConverter::toJSI(runtime, arg.modelId)); + obj.setProperty(runtime, "name", JSIConverter::toJSI(runtime, arg.name)); + obj.setProperty(runtime, "version", JSIConverter::toJSI(runtime, arg.version)); + obj.setProperty(runtime, "sizeMB", JSIConverter::toJSI(runtime, arg.sizeMB)); + obj.setProperty(runtime, "quantization", JSIConverter::toJSI(runtime, arg.quantization)); + obj.setProperty(runtime, "contextLength", JSIConverter::toJSI(runtime, arg.contextLength)); + obj.setProperty(runtime, "minMemoryMB", JSIConverter::toJSI(runtime, arg.minMemoryMB)); + obj.setProperty(runtime, "isMultimodal", JSIConverter::toJSI(runtime, arg.isMultimodal)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "modelId"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "name"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "version"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "sizeMB"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "quantization"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "contextLength"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "minMemoryMB"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "isMultimodal"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroProofreadCorrection.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroProofreadCorrection.hpp new file mode 100644 index 0000000..e6ad34c --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroProofreadCorrection.hpp @@ -0,0 +1,95 @@ +/// +/// NitroProofreadCorrection.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroProofreadCorrection). + */ + struct NitroProofreadCorrection { + public: + std::string original SWIFT_PRIVATE; + std::string corrected SWIFT_PRIVATE; + std::string type SWIFT_PRIVATE; + double confidence SWIFT_PRIVATE; + double startPos SWIFT_PRIVATE; + double endPos SWIFT_PRIVATE; + + public: + NitroProofreadCorrection() = default; + explicit NitroProofreadCorrection(std::string original, std::string corrected, std::string type, double confidence, double startPos, double endPos): original(original), corrected(corrected), type(type), confidence(confidence), startPos(startPos), endPos(endPos) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroProofreadCorrection <> JS NitroProofreadCorrection (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroProofreadCorrection fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroProofreadCorrection( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "original")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "corrected")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "type")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "confidence")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "startPos")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "endPos")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroProofreadCorrection& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "original", JSIConverter::toJSI(runtime, arg.original)); + obj.setProperty(runtime, "corrected", JSIConverter::toJSI(runtime, arg.corrected)); + obj.setProperty(runtime, "type", JSIConverter::toJSI(runtime, arg.type)); + obj.setProperty(runtime, "confidence", JSIConverter::toJSI(runtime, arg.confidence)); + obj.setProperty(runtime, "startPos", JSIConverter::toJSI(runtime, arg.startPos)); + obj.setProperty(runtime, "endPos", JSIConverter::toJSI(runtime, arg.endPos)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "original"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "corrected"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "type"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "confidence"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "startPos"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "endPos"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroProofreadResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroProofreadResult.hpp new file mode 100644 index 0000000..b7074a3 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroProofreadResult.hpp @@ -0,0 +1,86 @@ +/// +/// NitroProofreadResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroProofreadCorrection` to properly resolve imports. +namespace margelo::nitro::ondeviceai { struct NitroProofreadCorrection; } + +#include +#include "NitroProofreadCorrection.hpp" +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroProofreadResult). + */ + struct NitroProofreadResult { + public: + std::string correctedText SWIFT_PRIVATE; + std::vector corrections SWIFT_PRIVATE; + bool hasCorrections SWIFT_PRIVATE; + + public: + NitroProofreadResult() = default; + explicit NitroProofreadResult(std::string correctedText, std::vector corrections, bool hasCorrections): correctedText(correctedText), corrections(corrections), hasCorrections(hasCorrections) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroProofreadResult <> JS NitroProofreadResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroProofreadResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroProofreadResult( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "correctedText")), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "corrections")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "hasCorrections")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroProofreadResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "correctedText", JSIConverter::toJSI(runtime, arg.correctedText)); + obj.setProperty(runtime, "corrections", JSIConverter>::toJSI(runtime, arg.corrections)); + obj.setProperty(runtime, "hasCorrections", JSIConverter::toJSI(runtime, arg.hasCorrections)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "correctedText"))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "corrections"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "hasCorrections"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteOptions.hpp new file mode 100644 index 0000000..73568f8 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteOptions.hpp @@ -0,0 +1,76 @@ +/// +/// NitroRewriteOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroRewriteOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroRewriteOutputType; } + +#include "NitroRewriteOutputType.hpp" + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroRewriteOptions). + */ + struct NitroRewriteOptions { + public: + NitroRewriteOutputType outputType SWIFT_PRIVATE; + + public: + NitroRewriteOptions() = default; + explicit NitroRewriteOptions(NitroRewriteOutputType outputType): outputType(outputType) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroRewriteOptions <> JS NitroRewriteOptions (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroRewriteOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroRewriteOptions( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "outputType")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroRewriteOptions& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "outputType", JSIConverter::toJSI(runtime, arg.outputType)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "outputType"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteOutputType.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteOutputType.hpp new file mode 100644 index 0000000..b894d65 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteOutputType.hpp @@ -0,0 +1,92 @@ +/// +/// NitroRewriteOutputType.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::ondeviceai { + + /** + * An enum which can be represented as a JavaScript union (NitroRewriteOutputType). + */ + enum class NitroRewriteOutputType { + ELABORATE SWIFT_NAME(elaborate) = 0, + EMOJIFY SWIFT_NAME(emojify) = 1, + SHORTEN SWIFT_NAME(shorten) = 2, + FRIENDLY SWIFT_NAME(friendly) = 3, + PROFESSIONAL SWIFT_NAME(professional) = 4, + REPHRASE SWIFT_NAME(rephrase) = 5, + } CLOSED_ENUM; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroRewriteOutputType <> JS NitroRewriteOutputType (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroRewriteOutputType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("ELABORATE"): return margelo::nitro::ondeviceai::NitroRewriteOutputType::ELABORATE; + case hashString("EMOJIFY"): return margelo::nitro::ondeviceai::NitroRewriteOutputType::EMOJIFY; + case hashString("SHORTEN"): return margelo::nitro::ondeviceai::NitroRewriteOutputType::SHORTEN; + case hashString("FRIENDLY"): return margelo::nitro::ondeviceai::NitroRewriteOutputType::FRIENDLY; + case hashString("PROFESSIONAL"): return margelo::nitro::ondeviceai::NitroRewriteOutputType::PROFESSIONAL; + case hashString("REPHRASE"): return margelo::nitro::ondeviceai::NitroRewriteOutputType::REPHRASE; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NitroRewriteOutputType - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ondeviceai::NitroRewriteOutputType arg) { + switch (arg) { + case margelo::nitro::ondeviceai::NitroRewriteOutputType::ELABORATE: return JSIConverter::toJSI(runtime, "ELABORATE"); + case margelo::nitro::ondeviceai::NitroRewriteOutputType::EMOJIFY: return JSIConverter::toJSI(runtime, "EMOJIFY"); + case margelo::nitro::ondeviceai::NitroRewriteOutputType::SHORTEN: return JSIConverter::toJSI(runtime, "SHORTEN"); + case margelo::nitro::ondeviceai::NitroRewriteOutputType::FRIENDLY: return JSIConverter::toJSI(runtime, "FRIENDLY"); + case margelo::nitro::ondeviceai::NitroRewriteOutputType::PROFESSIONAL: return JSIConverter::toJSI(runtime, "PROFESSIONAL"); + case margelo::nitro::ondeviceai::NitroRewriteOutputType::REPHRASE: return JSIConverter::toJSI(runtime, "REPHRASE"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert NitroRewriteOutputType to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("ELABORATE"): + case hashString("EMOJIFY"): + case hashString("SHORTEN"): + case hashString("FRIENDLY"): + case hashString("PROFESSIONAL"): + case hashString("REPHRASE"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteResult.hpp new file mode 100644 index 0000000..e815f85 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroRewriteResult.hpp @@ -0,0 +1,83 @@ +/// +/// NitroRewriteResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroRewriteResult). + */ + struct NitroRewriteResult { + public: + std::string rewrittenText SWIFT_PRIVATE; + std::string style SWIFT_PRIVATE; + double confidence SWIFT_PRIVATE; + + public: + NitroRewriteResult() = default; + explicit NitroRewriteResult(std::string rewrittenText, std::string style, double confidence): rewrittenText(rewrittenText), style(style), confidence(confidence) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroRewriteResult <> JS NitroRewriteResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroRewriteResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroRewriteResult( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "rewrittenText")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "style")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "confidence")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroRewriteResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "rewrittenText", JSIConverter::toJSI(runtime, arg.rewrittenText)); + obj.setProperty(runtime, "style", JSIConverter::toJSI(runtime, arg.style)); + obj.setProperty(runtime, "confidence", JSIConverter::toJSI(runtime, arg.confidence)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "rewrittenText"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "style"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "confidence"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeInputType.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeInputType.hpp new file mode 100644 index 0000000..9b73e2b --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeInputType.hpp @@ -0,0 +1,76 @@ +/// +/// NitroSummarizeInputType.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::ondeviceai { + + /** + * An enum which can be represented as a JavaScript union (NitroSummarizeInputType). + */ + enum class NitroSummarizeInputType { + ARTICLE SWIFT_NAME(article) = 0, + CONVERSATION SWIFT_NAME(conversation) = 1, + } CLOSED_ENUM; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroSummarizeInputType <> JS NitroSummarizeInputType (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroSummarizeInputType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("ARTICLE"): return margelo::nitro::ondeviceai::NitroSummarizeInputType::ARTICLE; + case hashString("CONVERSATION"): return margelo::nitro::ondeviceai::NitroSummarizeInputType::CONVERSATION; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NitroSummarizeInputType - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ondeviceai::NitroSummarizeInputType arg) { + switch (arg) { + case margelo::nitro::ondeviceai::NitroSummarizeInputType::ARTICLE: return JSIConverter::toJSI(runtime, "ARTICLE"); + case margelo::nitro::ondeviceai::NitroSummarizeInputType::CONVERSATION: return JSIConverter::toJSI(runtime, "CONVERSATION"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert NitroSummarizeInputType to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("ARTICLE"): + case hashString("CONVERSATION"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeOptions.hpp new file mode 100644 index 0000000..bcb38aa --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeOptions.hpp @@ -0,0 +1,84 @@ +/// +/// NitroSummarizeOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +// Forward declaration of `NitroSummarizeInputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeInputType; } +// Forward declaration of `NitroSummarizeOutputType` to properly resolve imports. +namespace margelo::nitro::ondeviceai { enum class NitroSummarizeOutputType; } + +#include "NitroSummarizeInputType.hpp" +#include +#include "NitroSummarizeOutputType.hpp" + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroSummarizeOptions). + */ + struct NitroSummarizeOptions { + public: + std::optional inputType SWIFT_PRIVATE; + std::optional outputType SWIFT_PRIVATE; + + public: + NitroSummarizeOptions() = default; + explicit NitroSummarizeOptions(std::optional inputType, std::optional outputType): inputType(inputType), outputType(outputType) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroSummarizeOptions <> JS NitroSummarizeOptions (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroSummarizeOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroSummarizeOptions( + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "inputType")), + JSIConverter>::fromJSI(runtime, obj.getProperty(runtime, "outputType")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroSummarizeOptions& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "inputType", JSIConverter>::toJSI(runtime, arg.inputType)); + obj.setProperty(runtime, "outputType", JSIConverter>::toJSI(runtime, arg.outputType)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "inputType"))) return false; + if (!JSIConverter>::canConvert(runtime, obj.getProperty(runtime, "outputType"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeOutputType.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeOutputType.hpp new file mode 100644 index 0000000..d02acce --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeOutputType.hpp @@ -0,0 +1,80 @@ +/// +/// NitroSummarizeOutputType.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::ondeviceai { + + /** + * An enum which can be represented as a JavaScript union (NitroSummarizeOutputType). + */ + enum class NitroSummarizeOutputType { + ONE_BULLET SWIFT_NAME(oneBullet) = 0, + TWO_BULLETS SWIFT_NAME(twoBullets) = 1, + THREE_BULLETS SWIFT_NAME(threeBullets) = 2, + } CLOSED_ENUM; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroSummarizeOutputType <> JS NitroSummarizeOutputType (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroSummarizeOutputType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("ONE_BULLET"): return margelo::nitro::ondeviceai::NitroSummarizeOutputType::ONE_BULLET; + case hashString("TWO_BULLETS"): return margelo::nitro::ondeviceai::NitroSummarizeOutputType::TWO_BULLETS; + case hashString("THREE_BULLETS"): return margelo::nitro::ondeviceai::NitroSummarizeOutputType::THREE_BULLETS; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NitroSummarizeOutputType - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ondeviceai::NitroSummarizeOutputType arg) { + switch (arg) { + case margelo::nitro::ondeviceai::NitroSummarizeOutputType::ONE_BULLET: return JSIConverter::toJSI(runtime, "ONE_BULLET"); + case margelo::nitro::ondeviceai::NitroSummarizeOutputType::TWO_BULLETS: return JSIConverter::toJSI(runtime, "TWO_BULLETS"); + case margelo::nitro::ondeviceai::NitroSummarizeOutputType::THREE_BULLETS: return JSIConverter::toJSI(runtime, "THREE_BULLETS"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert NitroSummarizeOutputType to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("ONE_BULLET"): + case hashString("TWO_BULLETS"): + case hashString("THREE_BULLETS"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeResult.hpp new file mode 100644 index 0000000..c0e9072 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroSummarizeResult.hpp @@ -0,0 +1,87 @@ +/// +/// NitroSummarizeResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroSummarizeResult). + */ + struct NitroSummarizeResult { + public: + std::string summary SWIFT_PRIVATE; + double originalLength SWIFT_PRIVATE; + double summaryLength SWIFT_PRIVATE; + double confidence SWIFT_PRIVATE; + + public: + NitroSummarizeResult() = default; + explicit NitroSummarizeResult(std::string summary, double originalLength, double summaryLength, double confidence): summary(summary), originalLength(originalLength), summaryLength(summaryLength), confidence(confidence) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroSummarizeResult <> JS NitroSummarizeResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroSummarizeResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroSummarizeResult( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "summary")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "originalLength")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "summaryLength")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "confidence")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroSummarizeResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "summary", JSIConverter::toJSI(runtime, arg.summary)); + obj.setProperty(runtime, "originalLength", JSIConverter::toJSI(runtime, arg.originalLength)); + obj.setProperty(runtime, "summaryLength", JSIConverter::toJSI(runtime, arg.summaryLength)); + obj.setProperty(runtime, "confidence", JSIConverter::toJSI(runtime, arg.confidence)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "summary"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "originalLength"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "summaryLength"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "confidence"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTextStreamChunk.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTextStreamChunk.hpp new file mode 100644 index 0000000..40962d8 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTextStreamChunk.hpp @@ -0,0 +1,83 @@ +/// +/// NitroTextStreamChunk.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroTextStreamChunk). + */ + struct NitroTextStreamChunk { + public: + std::string delta SWIFT_PRIVATE; + std::string accumulated SWIFT_PRIVATE; + bool isFinal SWIFT_PRIVATE; + + public: + NitroTextStreamChunk() = default; + explicit NitroTextStreamChunk(std::string delta, std::string accumulated, bool isFinal): delta(delta), accumulated(accumulated), isFinal(isFinal) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroTextStreamChunk <> JS NitroTextStreamChunk (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroTextStreamChunk fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroTextStreamChunk( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "delta")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "accumulated")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "isFinal")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroTextStreamChunk& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "delta", JSIConverter::toJSI(runtime, arg.delta)); + obj.setProperty(runtime, "accumulated", JSIConverter::toJSI(runtime, arg.accumulated)); + obj.setProperty(runtime, "isFinal", JSIConverter::toJSI(runtime, arg.isFinal)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "delta"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "accumulated"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "isFinal"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTranslateOptions.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTranslateOptions.hpp new file mode 100644 index 0000000..a959d1d --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTranslateOptions.hpp @@ -0,0 +1,79 @@ +/// +/// NitroTranslateOptions.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroTranslateOptions). + */ + struct NitroTranslateOptions { + public: + std::string sourceLanguage SWIFT_PRIVATE; + std::string targetLanguage SWIFT_PRIVATE; + + public: + NitroTranslateOptions() = default; + explicit NitroTranslateOptions(std::string sourceLanguage, std::string targetLanguage): sourceLanguage(sourceLanguage), targetLanguage(targetLanguage) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroTranslateOptions <> JS NitroTranslateOptions (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroTranslateOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroTranslateOptions( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "sourceLanguage")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "targetLanguage")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroTranslateOptions& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "sourceLanguage", JSIConverter::toJSI(runtime, arg.sourceLanguage)); + obj.setProperty(runtime, "targetLanguage", JSIConverter::toJSI(runtime, arg.targetLanguage)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "sourceLanguage"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "targetLanguage"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTranslateResult.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTranslateResult.hpp new file mode 100644 index 0000000..96370d8 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/NitroTranslateResult.hpp @@ -0,0 +1,87 @@ +/// +/// NitroTranslateResult.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + + + +#include + +namespace margelo::nitro::ondeviceai { + + /** + * A struct which can be represented as a JavaScript object (NitroTranslateResult). + */ + struct NitroTranslateResult { + public: + std::string translatedText SWIFT_PRIVATE; + std::string sourceLanguage SWIFT_PRIVATE; + std::string targetLanguage SWIFT_PRIVATE; + double confidence SWIFT_PRIVATE; + + public: + NitroTranslateResult() = default; + explicit NitroTranslateResult(std::string translatedText, std::string sourceLanguage, std::string targetLanguage, double confidence): translatedText(translatedText), sourceLanguage(sourceLanguage), targetLanguage(targetLanguage), confidence(confidence) {} + }; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ NitroTranslateResult <> JS NitroTranslateResult (object) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::NitroTranslateResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + jsi::Object obj = arg.asObject(runtime); + return margelo::nitro::ondeviceai::NitroTranslateResult( + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "translatedText")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "sourceLanguage")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "targetLanguage")), + JSIConverter::fromJSI(runtime, obj.getProperty(runtime, "confidence")) + ); + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ondeviceai::NitroTranslateResult& arg) { + jsi::Object obj(runtime); + obj.setProperty(runtime, "translatedText", JSIConverter::toJSI(runtime, arg.translatedText)); + obj.setProperty(runtime, "sourceLanguage", JSIConverter::toJSI(runtime, arg.sourceLanguage)); + obj.setProperty(runtime, "targetLanguage", JSIConverter::toJSI(runtime, arg.targetLanguage)); + obj.setProperty(runtime, "confidence", JSIConverter::toJSI(runtime, arg.confidence)); + return obj; + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isObject()) { + return false; + } + jsi::Object obj = value.getObject(runtime); + if (!nitro::isPlainObject(runtime, obj)) { + return false; + } + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "translatedText"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "sourceLanguage"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "targetLanguage"))) return false; + if (!JSIConverter::canConvert(runtime, obj.getProperty(runtime, "confidence"))) return false; + return true; + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/OndeviceAiPlatform.hpp b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/OndeviceAiPlatform.hpp new file mode 100644 index 0000000..8840929 --- /dev/null +++ b/libraries/react-native-ondevice-ai/nitrogen/generated/shared/c++/OndeviceAiPlatform.hpp @@ -0,0 +1,76 @@ +/// +/// OndeviceAiPlatform.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © 2026 Marc Rousavy @ Margelo +/// + +#pragma once + +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::ondeviceai { + + /** + * An enum which can be represented as a JavaScript union (OndeviceAiPlatform). + */ + enum class OndeviceAiPlatform { + APPLE SWIFT_NAME(apple) = 0, + GOOGLE SWIFT_NAME(google) = 1, + } CLOSED_ENUM; + +} // namespace margelo::nitro::ondeviceai + +namespace margelo::nitro { + + // C++ OndeviceAiPlatform <> JS OndeviceAiPlatform (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::ondeviceai::OndeviceAiPlatform fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("apple"): return margelo::nitro::ondeviceai::OndeviceAiPlatform::APPLE; + case hashString("google"): return margelo::nitro::ondeviceai::OndeviceAiPlatform::GOOGLE; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum OndeviceAiPlatform - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ondeviceai::OndeviceAiPlatform arg) { + switch (arg) { + case margelo::nitro::ondeviceai::OndeviceAiPlatform::APPLE: return JSIConverter::toJSI(runtime, "apple"); + case margelo::nitro::ondeviceai::OndeviceAiPlatform::GOOGLE: return JSIConverter::toJSI(runtime, "google"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert OndeviceAiPlatform to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("apple"): + case hashString("google"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/libraries/react-native-ondevice-ai/src/__mocks__/react-native-nitro-modules.js b/libraries/react-native-ondevice-ai/src/__mocks__/react-native-nitro-modules.js index f5a0760..9203c5e 100644 --- a/libraries/react-native-ondevice-ai/src/__mocks__/react-native-nitro-modules.js +++ b/libraries/react-native-ondevice-ai/src/__mocks__/react-native-nitro-modules.js @@ -1,4 +1,7 @@ const chatStreamListeners = []; +const summarizeStreamListeners = []; +const translateStreamListeners = []; +const rewriteStreamListeners = []; const modelDownloadProgressListeners = []; const mockHybridObject = { @@ -58,17 +61,54 @@ const mockHybridObject = { canContinue: true, }); }), + summarizeStreaming: jest.fn().mockImplementation(() => { + const chunk = {delta: 'Mock summary', accumulated: 'Mock summary', isFinal: true}; + Promise.resolve().then(() => { + summarizeStreamListeners.forEach((l) => l(chunk)); + }); + return Promise.resolve({summary: 'Mock summary', originalLength: 100, summaryLength: 12, confidence: 0.9}); + }), + addSummarizeStreamListener: jest.fn().mockImplementation((l) => { summarizeStreamListeners.push(l); }), + removeSummarizeStreamListener: jest.fn().mockImplementation((l) => { + const idx = summarizeStreamListeners.indexOf(l); + if (idx >= 0) summarizeStreamListeners.splice(idx, 1); + }), translate: jest.fn().mockResolvedValue({ translatedText: 'Mock translation', sourceLanguage: 'en', targetLanguage: 'ko', confidence: 0.9, }), + translateStreaming: jest.fn().mockImplementation(() => { + const chunk = {delta: 'Mock translation', accumulated: 'Mock translation', isFinal: true}; + Promise.resolve().then(() => { + translateStreamListeners.forEach((l) => l(chunk)); + }); + return Promise.resolve({translatedText: 'Mock translation', sourceLanguage: 'en', targetLanguage: 'ko', confidence: 0.9}); + }), + addTranslateStreamListener: jest.fn().mockImplementation((l) => { translateStreamListeners.push(l); }), + removeTranslateStreamListener: jest.fn().mockImplementation((l) => { + const idx = translateStreamListeners.indexOf(l); + if (idx >= 0) translateStreamListeners.splice(idx, 1); + }), rewrite: jest.fn().mockResolvedValue({ rewrittenText: 'Mock rewritten text', style: 'PROFESSIONAL', confidence: 0.9, }), + rewriteStreaming: jest.fn().mockImplementation(() => { + const chunk = {delta: 'Mock rewritten text', accumulated: 'Mock rewritten text', isFinal: true}; + Promise.resolve().then(() => { + rewriteStreamListeners.forEach((l) => l(chunk)); + }); + return Promise.resolve({rewrittenText: 'Mock rewritten text', style: 'PROFESSIONAL', confidence: 0.9}); + }), + addRewriteStreamListener: jest.fn().mockImplementation((l) => { rewriteStreamListeners.push(l); }), + removeRewriteStreamListener: jest.fn().mockImplementation((l) => { + const idx = rewriteStreamListeners.indexOf(l); + if (idx >= 0) rewriteStreamListeners.splice(idx, 1); + }), + describeImage: jest.fn().mockResolvedValue({description: 'A mock image description', confidence: 0.9}), proofread: jest.fn().mockResolvedValue({ correctedText: 'This is a test.', corrections: [], @@ -107,5 +147,8 @@ module.exports = { }, __mockHybridObject: mockHybridObject, __chatStreamListeners: chatStreamListeners, + __summarizeStreamListeners: summarizeStreamListeners, + __translateStreamListeners: translateStreamListeners, + __rewriteStreamListeners: rewriteStreamListeners, __modelDownloadProgressListeners: modelDownloadProgressListeners, }; diff --git a/libraries/react-native-ondevice-ai/src/__tests__/index.test.ts b/libraries/react-native-ondevice-ai/src/__tests__/index.test.ts index 95776df..9a7778e 100644 --- a/libraries/react-native-ondevice-ai/src/__tests__/index.test.ts +++ b/libraries/react-native-ondevice-ai/src/__tests__/index.test.ts @@ -2,13 +2,17 @@ import { initialize, getDeviceCapability, summarize, + summarizeStreaming, classify, extract, chat, chatStream, translate, + translateStreaming, rewrite, + rewriteStreaming, proofread, + describeImage, getAvailableModels, getDownloadedModels, getLoadedModel, @@ -20,7 +24,7 @@ import { downloadPromptApiModel, isNitroReady, } from '../index'; -import type {ChatStreamChunk} from '../types'; +import type {ChatStreamChunk, TextStreamChunk} from '../types'; describe('react-native-ondevice-ai', () => { describe('isNitroReady', () => { @@ -173,6 +177,28 @@ describe('react-native-ondevice-ai', () => { }); }); + describe('summarizeStreaming', () => { + it('should return summarize result', async () => { + const result = await summarizeStreaming('Long text to summarize.'); + expect(result).toHaveProperty('summary'); + expect(result).toHaveProperty('originalLength'); + }); + + it('should invoke onChunk with final chunk', async () => { + const chunks: TextStreamChunk[] = []; + await summarizeStreaming('Text', {onChunk: (c) => chunks.push(c)}); + expect(chunks.length).toBe(1); + expect(chunks[0]!.isFinal).toBe(true); + }); + + it('should clean up listener after completion', async () => { + const {__mockHybridObject: mock} = require('react-native-nitro-modules'); + await summarizeStreaming('Text', {onChunk: jest.fn()}); + expect(mock.addSummarizeStreamListener).toHaveBeenCalled(); + expect(mock.removeSummarizeStreamListener).toHaveBeenCalled(); + }); + }); + describe('translate', () => { it('should translate text', async () => { const result = await translate('Hello', {targetLanguage: 'ko'}); @@ -182,6 +208,27 @@ describe('react-native-ondevice-ai', () => { }); }); + describe('translateStreaming', () => { + it('should return translate result', async () => { + const result = await translateStreaming('Hello', {targetLanguage: 'ko'}); + expect(result).toHaveProperty('translatedText'); + }); + + it('should invoke onChunk with final chunk', async () => { + const chunks: TextStreamChunk[] = []; + await translateStreaming('Hello', {targetLanguage: 'ko', onChunk: (c) => chunks.push(c)}); + expect(chunks.length).toBe(1); + expect(chunks[0]!.isFinal).toBe(true); + }); + + it('should clean up listener after completion', async () => { + const {__mockHybridObject: mock} = require('react-native-nitro-modules'); + await translateStreaming('Hello', {targetLanguage: 'ko', onChunk: jest.fn()}); + expect(mock.addTranslateStreamListener).toHaveBeenCalled(); + expect(mock.removeTranslateStreamListener).toHaveBeenCalled(); + }); + }); + describe('rewrite', () => { it('should rewrite text', async () => { const result = await rewrite('This is a test.', { @@ -191,6 +238,40 @@ describe('react-native-ondevice-ai', () => { }); }); + describe('rewriteStreaming', () => { + it('should return rewrite result', async () => { + const result = await rewriteStreaming('Text.', {outputType: 'PROFESSIONAL'}); + expect(result).toHaveProperty('rewrittenText'); + }); + + it('should invoke onChunk with final chunk', async () => { + const chunks: TextStreamChunk[] = []; + await rewriteStreaming('Text.', {outputType: 'PROFESSIONAL', onChunk: (c) => chunks.push(c)}); + expect(chunks.length).toBe(1); + expect(chunks[0]!.isFinal).toBe(true); + }); + + it('should clean up listener after completion', async () => { + const {__mockHybridObject: mock} = require('react-native-nitro-modules'); + await rewriteStreaming('Text.', {outputType: 'PROFESSIONAL', onChunk: jest.fn()}); + expect(mock.addRewriteStreamListener).toHaveBeenCalled(); + expect(mock.removeRewriteStreamListener).toHaveBeenCalled(); + }); + }); + + describe('describeImage', () => { + it('should return image description', async () => { + const result = await describeImage('file:///path/to/image.jpg'); + expect(result).toHaveProperty('description'); + expect(result).toHaveProperty('confidence'); + }); + + it('should accept optional prompt', async () => { + const result = await describeImage('file:///path/to/image.jpg', {prompt: 'What is in this image?'}); + expect(result).toHaveProperty('description'); + }); + }); + describe('proofread', () => { it('should proofread text', async () => { const result = await proofread('This is a test.'); diff --git a/libraries/react-native-ondevice-ai/src/index.ts b/libraries/react-native-ondevice-ai/src/index.ts index f2df556..14157f2 100644 --- a/libraries/react-native-ondevice-ai/src/index.ts +++ b/libraries/react-native-ondevice-ai/src/index.ts @@ -6,11 +6,13 @@ import type { OndeviceAi, NitroChatStreamChunk, NitroModelDownloadProgress, + NitroTextStreamChunk, } from './specs/OndeviceAi.nitro'; import type { DeviceCapability, SummarizeOptions, SummarizeResult, + SummarizeStreamOptions, ClassifyOptions, ClassifyResult, ExtractOptions, @@ -19,16 +21,21 @@ import type { ChatResult, ChatStreamOptions, ChatStreamChunk, + TextStreamChunk, TranslateOptions, TranslateResult, + TranslateStreamOptions, RewriteOptions, RewriteResult, + RewriteStreamOptions, ProofreadOptions, ProofreadResult, InitializeResult, DownloadableModelInfo, InferenceEngine, ModelDownloadProgress, + DescribeImageOptions, + DescribeImageResult, } from './types'; // Re-export all public types @@ -47,10 +54,13 @@ export type { ChatResult, ChatStreamOptions, ChatStreamChunk, + TextStreamChunk, TranslateOptions, TranslateResult, + TranslateStreamOptions, RewriteOptions, RewriteResult, + RewriteStreamOptions, ProofreadCorrection, ProofreadOptions, ProofreadResult, @@ -59,6 +69,9 @@ export type { InferenceEngine, ModelDownloadProgress, EventSubscription, + SummarizeStreamOptions, + DescribeImageOptions, + DescribeImageResult, } from './types'; export type { @@ -375,6 +388,140 @@ export async function proofread( }; } +// ────────────────────────────────────────────────────────────────────────── +// Streaming Variants +// ────────────────────────────────────────────────────────────────────────── + +/** Summarize text with progressive token streaming via onChunk callback. */ +export async function summarizeStreaming( + text: string, + options?: SummarizeStreamOptions, +): Promise { + let listener: ((chunk: NitroTextStreamChunk) => void) | null = null; + + try { + if (options?.onChunk) { + listener = (chunk: NitroTextStreamChunk) => { + const converted: TextStreamChunk = { + delta: chunk.delta, + accumulated: chunk.accumulated, + isFinal: chunk.isFinal, + }; + options.onChunk!(converted); + }; + AI.instance.addSummarizeStreamListener(listener); + } + + const result = await AI.instance.summarizeStreaming(text, options ? { + inputType: options.inputType ? (options.inputType as never) : null, + outputType: options.outputType ? (options.outputType as never) : null, + } : null); + + return { + summary: result.summary, + originalLength: result.originalLength, + summaryLength: result.summaryLength, + confidence: result.confidence, + }; + } finally { + if (listener) AI.instance.removeSummarizeStreamListener(listener); + } +} + +/** Translate text with progressive token streaming via onChunk callback. */ +export async function translateStreaming( + text: string, + options: TranslateStreamOptions, +): Promise { + let listener: ((chunk: NitroTextStreamChunk) => void) | null = null; + + try { + if (options.onChunk) { + listener = (chunk: NitroTextStreamChunk) => { + const converted: TextStreamChunk = { + delta: chunk.delta, + accumulated: chunk.accumulated, + isFinal: chunk.isFinal, + }; + options.onChunk!(converted); + }; + AI.instance.addTranslateStreamListener(listener); + } + + const result = await AI.instance.translateStreaming(text, { + sourceLanguage: options.sourceLanguage ?? 'en', + targetLanguage: options.targetLanguage, + }); + + return { + translatedText: result.translatedText, + sourceLanguage: result.sourceLanguage, + targetLanguage: result.targetLanguage, + confidence: result.confidence, + }; + } finally { + if (listener) AI.instance.removeTranslateStreamListener(listener); + } +} + +/** Rewrite text with progressive token streaming via onChunk callback. */ +export async function rewriteStreaming( + text: string, + options: RewriteStreamOptions, +): Promise { + let listener: ((chunk: NitroTextStreamChunk) => void) | null = null; + + try { + if (options.onChunk) { + listener = (chunk: NitroTextStreamChunk) => { + const converted: TextStreamChunk = { + delta: chunk.delta, + accumulated: chunk.accumulated, + isFinal: chunk.isFinal, + }; + options.onChunk!(converted); + }; + AI.instance.addRewriteStreamListener(listener); + } + + const result = await AI.instance.rewriteStreaming(text, { + outputType: options.outputType as never, + }); + + return { + rewrittenText: result.rewrittenText, + style: result.style as RewriteOptions['outputType'], + confidence: result.confidence, + }; + } finally { + if (listener) AI.instance.removeRewriteStreamListener(listener); + } +} + +// ────────────────────────────────────────────────────────────────────────── +// Image Description +// ────────────────────────────────────────────────────────────────────────── + +/** + * Describe the contents of an image using on-device AI. + * Supported on iOS (Foundation Models Vision) and Android. + * @param imageUri - URI or file path to the image + * @param options - Optional prompt and other options + */ +export async function describeImage( + imageUri: string, + options?: DescribeImageOptions, +): Promise { + const result = await AI.instance.describeImage(imageUri, options ? { + prompt: options.prompt ?? null, + } : null); + + return { + description: result.description, + confidence: result.confidence, + }; +} + // ────────────────────────────────────────────────────────────────────────── // Model Management // ────────────────────────────────────────────────────────────────────────── diff --git a/libraries/react-native-ondevice-ai/src/specs/OndeviceAi.nitro.ts b/libraries/react-native-ondevice-ai/src/specs/OndeviceAi.nitro.ts index 68bc4af..9b7e080 100644 --- a/libraries/react-native-ondevice-ai/src/specs/OndeviceAi.nitro.ts +++ b/libraries/react-native-ondevice-ai/src/specs/OndeviceAi.nitro.ts @@ -202,6 +202,29 @@ export interface NitroProofreadResult { hasCorrections: boolean; } +// ────────────────────────────────────────────────────────────────────────── +// Streaming Chunk (shared by summarize / translate / rewrite streaming) +// ────────────────────────────────────────────────────────────────────────── + +export interface NitroTextStreamChunk { + delta: string; + accumulated: string; + isFinal: boolean; +} + +// ────────────────────────────────────────────────────────────────────────── +// Image Description +// ────────────────────────────────────────────────────────────────────────── + +export interface NitroDescribeImageOptions { + prompt?: string | null; +} + +export interface NitroDescribeImageResult { + description: string; + confidence: number; +} + // ────────────────────────────────────────────────────────────────────────── // Model Management // ────────────────────────────────────────────────────────────────────────── @@ -274,6 +297,46 @@ export interface OndeviceAi listener: (chunk: NitroChatStreamChunk) => void, ): void; + // Streaming Variants for summarize / translate / rewrite + summarizeStreaming( + text: string, + options?: NitroSummarizeOptions | null, + ): Promise; + addSummarizeStreamListener( + listener: (chunk: NitroTextStreamChunk) => void, + ): void; + removeSummarizeStreamListener( + listener: (chunk: NitroTextStreamChunk) => void, + ): void; + + translateStreaming( + text: string, + options: NitroTranslateOptions, + ): Promise; + addTranslateStreamListener( + listener: (chunk: NitroTextStreamChunk) => void, + ): void; + removeTranslateStreamListener( + listener: (chunk: NitroTextStreamChunk) => void, + ): void; + + rewriteStreaming( + text: string, + options: NitroRewriteOptions, + ): Promise; + addRewriteStreamListener( + listener: (chunk: NitroTextStreamChunk) => void, + ): void; + removeRewriteStreamListener( + listener: (chunk: NitroTextStreamChunk) => void, + ): void; + + // Image Description + describeImage( + imageUri: string, + options?: NitroDescribeImageOptions | null, + ): Promise; + // Model Management getAvailableModels(): Promise; getDownloadedModels(): Promise; diff --git a/libraries/react-native-ondevice-ai/src/types.ts b/libraries/react-native-ondevice-ai/src/types.ts index 22ce604..fdf89ff 100644 --- a/libraries/react-native-ondevice-ai/src/types.ts +++ b/libraries/react-native-ondevice-ai/src/types.ts @@ -283,3 +283,49 @@ export interface ModelDownloadProgress { export interface EventSubscription { remove(): void; } + +// MARK: - Streaming Chunk (shared by summarize / translate / rewrite) + +/** A single streamed token chunk for text-generation streaming APIs */ +export interface TextStreamChunk { + /** New text delta in this chunk */ + delta: string; + /** Full accumulated text so far */ + accumulated: string; + /** Whether this is the final chunk */ + isFinal: boolean; +} + +/** Options for streaming summarization */ +export interface SummarizeStreamOptions extends SummarizeOptions { + /** Callback invoked for each streamed token */ + onChunk?: (chunk: TextStreamChunk) => void; +} + +/** Options for streaming translation */ +export interface TranslateStreamOptions extends TranslateOptions { + /** Callback invoked for each streamed token */ + onChunk?: (chunk: TextStreamChunk) => void; +} + +/** Options for streaming rewrite */ +export interface RewriteStreamOptions extends RewriteOptions { + /** Callback invoked for each streamed token */ + onChunk?: (chunk: TextStreamChunk) => void; +} + +// MARK: - Image Description + +/** Options for image description */ +export interface DescribeImageOptions { + /** Optional prompt to guide the description */ + prompt?: string; +} + +/** Result of image description */ +export interface DescribeImageResult { + /** The generated description */ + description: string; + /** Confidence score (0-1) */ + confidence?: number; +}