@iternio/react-native-auto-play 0.4.4 → 0.4.5

package/ios/hybrid/HybridVoice.swift

@@ -0,0 +1,63 @@
+import AVFoundation
+import NitroModules
+import Speech
+
+class HybridVoice: HybridVoiceSpec {
+    private var voiceInputManager: VoiceInputManager?
+
+    func hasVoiceInputPermission() throws -> Bool {
+        let micGranted = AVAudioSession.sharedInstance().recordPermission == .granted
+        let speechGranted = SFSpeechRecognizer.authorizationStatus() == .authorized
+        return micGranted && speechGranted
+    }
+
+    func requestVoiceInputPermission() throws -> Promise<Bool> {
+        return Promise.async {
+            let micGranted = await withCheckedContinuation { cont in
+                AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                    cont.resume(returning: granted)
+                }
+            }
+            guard micGranted else { return false }
+
+            return await withCheckedContinuation { cont in
+                SFSpeechRecognizer.requestAuthorization { status in
+                    cont.resume(returning: status == .authorized)
+                }
+            }
+        }
+    }
+
+    func startVoiceInput(
+        silenceThresholdMs: Double?,
+        maxDurationMs: Double?,
+        listeningText: String?,
+        preferSpeechToText: Bool?,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?
+    ) throws -> Promise<VoiceInputResult> {
+        return Promise.async {
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+
+            let manager = VoiceInputManager()
+            self.voiceInputManager = manager
+
+            defer { self.voiceInputManager = nil }
+
+            return try await manager.start(
+                interfaceController: interfaceController,
+                silenceThresholdMs: silenceThresholdMs ?? 1_500,
+                maxDurationMs: maxDurationMs ?? 10_000,
+                listeningText: listeningText ?? "Listening...",
+                preferSpeechToText: preferSpeechToText ?? false,
+                onChunk: onChunk
+            )
+        }
+    }
+
+    func stopVoiceInput() throws {
+        Task { @MainActor in
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+            self.voiceInputManager?.stop(interfaceController: interfaceController)
+        }
+    }
+}

package/ios/utils/VoiceInputManager.swift

@@ -1,16 +1,47 @@
 import AVFoundation
 import CarPlay
+import NitroModules
+import Speech
 
-/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM.
-/// Recording stops automatically when silence is detected or the max duration is reached.
+/// Wraps CheckedContinuation so it can only be resumed once even when
+/// shared between a stop() call and an async recognition task callback.
+private final class ResultBox: @unchecked Sendable {
+    private var continuation: CheckedContinuation<VoiceInputResult, Error>?
+    private let lock = NSLock()
+
+    init(_ continuation: CheckedContinuation<VoiceInputResult, Error>) {
+        self.continuation = continuation
+    }
+
+    func resume(returning result: VoiceInputResult) {
+        lock.lock()
+        defer { lock.unlock() }
+        continuation?.resume(returning: result)
+        continuation = nil
+    }
+
+    func resume(throwing error: Error) {
+        lock.lock()
+        defer { lock.unlock() }
+        continuation?.resume(throwing: error)
+        continuation = nil
+    }
+}
+
+/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM,
+/// or transcribes it via SFSpeechRecognizer when preferSpeechToText is true.
 class VoiceInputManager {
     private var audioEngine: AVAudioEngine?
     private var voiceControlTemplate: CPVoiceControlTemplate?
-    private var continuation: CheckedContinuation<[Int16], Error>?
+    private var resultBox: ResultBox?
     private var samples: [Int16] = []
     private var isStopping = false
     private let stopLock = NSLock()
 
+    // STT
+    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
+    private var isSTTMode = false
+
     // Timing
     private var recordingStart: Date?
     private var silenceStart: Date?
@@ -33,30 +64,33 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String
-    ) async throws -> Data {
-        let samples = try await withCheckedThrowingContinuation {
-            (cont: CheckedContinuation<[Int16], Error>) in
-            self.continuation = cont
+        listeningText: String,
+        preferSpeechToText: Bool,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?
+    ) async throws -> VoiceInputResult {
+        return try await withCheckedThrowingContinuation { cont in
+            let box = ResultBox(cont)
+            self.resultBox = box
             self.samples = []
             self.isStopping = false
+            self.isSTTMode = preferSpeechToText
 
             do {
                 try self.startCapture(
                     interfaceController: interfaceController,
                     silenceThresholdMs: silenceThresholdMs,
                     maxDurationMs: maxDurationMs,
-                    listeningText: listeningText
+                    listeningText: listeningText,
+                    preferSpeechToText: preferSpeechToText,
+                    onChunk: onChunk,
+                    box: box
                 )
             }
             catch {
-                self.stopCapture(interfaceController: interfaceController)
-                self.continuation = nil
-                cont.resume(throwing: error)
+                self.cleanup(interfaceController: interfaceController)
+                box.resume(throwing: error)
             }
         }
-
-        return samplesAsData(samples)
     }
 
     func stop(interfaceController: AutoPlayInterfaceController? = nil) {
@@ -66,14 +100,22 @@ class VoiceInputManager {
             return
         }
         isStopping = true
-        let capturedContinuation = continuation
+        let wasSTTMode = isSTTMode
+        let box = resultBox
         let capturedSamples = samples
-        continuation = nil
+        resultBox = nil
         samples = []
         stopLock.unlock()
 
-        stopCapture(interfaceController: interfaceController)
-        capturedContinuation?.resume(returning: capturedSamples)
+        if wasSTTMode {
+            // endAudio() causes the recognition task to fire its final result,
+            // which resumes the box. Engine teardown happens there too.
+            recognitionRequest?.endAudio()
+        }
+        else {
+            cleanup(interfaceController: interfaceController)
+            box?.resume(returning: makePCMResult(from: capturedSamples))
+        }
     }
 
     // MARK: - Private
@@ -82,13 +124,15 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String
+        listeningText: String,
+        preferSpeechToText: Bool,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
+        box: ResultBox
     ) throws {
         guard AVAudioSession.sharedInstance().recordPermission == .granted else {
             throw VoiceInputError.microphonePermissionDenied
         }
 
-        // Activate the session first so inputNode reports the correct hardware format
         let session = AVAudioSession.sharedInstance()
         try session.setCategory(.playAndRecord, mode: .measurement, options: [])
         try session.setActive(true)
@@ -97,12 +141,59 @@ class VoiceInputManager {
             presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
         }
 
+        var activeRecognitionRequest: SFSpeechAudioBufferRecognitionRequest? = nil
+
+        if preferSpeechToText, SFSpeechRecognizer.authorizationStatus() == .authorized,
+            let recognizer = SFSpeechRecognizer(locale: Locale.current),
+            recognizer.isAvailable
+        {
+            let request = SFSpeechAudioBufferRecognitionRequest()
+            request.shouldReportPartialResults = true
+            recognitionRequest = request
+            activeRecognitionRequest = request
+
+            recognizer.recognitionTask(with: request) { [weak self] result, error in
+                guard let self else { return }
+
+                if error != nil {
+                    // STT failed — fall back to whatever PCM was accumulated
+                    self.stopLock.lock()
+                    let capturedSamples = self.samples
+                    self.samples = []
+                    self.stopLock.unlock()
+
+                    self.cleanup(interfaceController: interfaceController)
+                    box.resume(returning: self.makePCMResult(from: capturedSamples))
+                    return
+                }
+
+                guard let result else { return }
+
+                if result.isFinal {
+                    self.stopLock.lock()
+                    self.isStopping = true
+                    self.samples = []
+                    self.stopLock.unlock()
+
+                    self.cleanup(interfaceController: interfaceController)
+                    box.resume(
+                        returning: VoiceInputResult(
+                            transcription: result.bestTranscription.formattedString,
+                            audio: nil
+                        )
+                    )
+                }
+                else {
+                    onChunk?(VoiceInputChunk(partial: result.bestTranscription.formattedString, audio: nil))
+                }
+            }
+        }
+
         let engine = AVAudioEngine()
         let inputNode = engine.inputNode
         let nativeFormat = inputNode.outputFormat(forBus: 0)
 
-        let targetFormat = VoiceInputManager.targetFormat
-        guard let converter = AVAudioConverter(from: nativeFormat, to: targetFormat) else {
+        guard let converter = AVAudioConverter(from: nativeFormat, to: VoiceInputManager.targetFormat) else {
             throw VoiceInputError.converterUnavailable
         }
 
@@ -116,36 +207,43 @@ class VoiceInputManager {
         ) { [weak self] buffer, _ in
             guard let self, !self.isStopping else { return }
 
+            // Feed STT if active
+            activeRecognitionRequest?.append(buffer)
+
+            // Convert to 16kHz int16 for accumulation and PCM chunks
             let outputFrameCapacity = AVAudioFrameCount(
-                Double(buffer.frameLength)
-                    * VoiceInputManager.sampleRate
-                    / nativeFormat.sampleRate
+                Double(buffer.frameLength) * VoiceInputManager.sampleRate / nativeFormat.sampleRate
             )
-
             guard
                 let outputBuffer = AVAudioPCMBuffer(
-                    pcmFormat: targetFormat,
+                    pcmFormat: VoiceInputManager.targetFormat,
                     frameCapacity: outputFrameCapacity
                 )
             else { return }
 
             var conversionError: NSError?
-            let status = converter.convert(to: outputBuffer, error: &conversionError) {
-                _,
-                outStatus in
+            let status = converter.convert(to: outputBuffer, error: &conversionError) { _, outStatus in
                 outStatus.pointee = .haveData
                 return buffer
             }
-
             guard status != .error, let int16Data = outputBuffer.int16ChannelData else { return }
 
             let frameCount = Int(outputBuffer.frameLength)
             let newSamples = Array(UnsafeBufferPointer(start: int16Data[0], count: frameCount))
             self.samples.append(contentsOf: newSamples)
 
+            // PCM chunk callback
+            if activeRecognitionRequest == nil, let onChunk {
+                if let chunkBuffer = try? ArrayBuffer.copy(
+                    data: newSamples.withUnsafeBufferPointer { Data(buffer: $0) }
+                ) {
+                    onChunk(VoiceInputChunk(partial: nil, audio: chunkBuffer))
+                }
+            }
+
             let now = Date()
 
-            // Max duration check
+            // Max duration — applies in both modes
             if let start = self.recordingStart,
                 now.timeIntervalSince(start) * 1000 >= maxDurationMs
             {
@@ -160,7 +258,9 @@ class VoiceInputManager {
             {
                 let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
                 if peak < VoiceInputManager.silenceAmplitudeThreshold {
-                    if self.silenceStart == nil { self.silenceStart = now }
+                    if self.silenceStart == nil {
+                        self.silenceStart = now
+                    }
                     if let silenceBegin = self.silenceStart,
                         now.timeIntervalSince(silenceBegin) * 1000 >= silenceThresholdMs
                     {
@@ -183,10 +283,11 @@ class VoiceInputManager {
         }
     }
 
-    private func stopCapture(interfaceController: AutoPlayInterfaceController?) {
+    private func cleanup(interfaceController: AutoPlayInterfaceController?) {
         audioEngine?.inputNode.removeTap(onBus: 0)
         audioEngine?.stop()
         audioEngine = nil
+        recognitionRequest = nil
         recordingStart = nil
         silenceStart = nil
         try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
@@ -195,6 +296,12 @@ class VoiceInputManager {
         }
     }
 
+    private func makePCMResult(from samples: [Int16]) -> VoiceInputResult {
+        let data = samples.withUnsafeBufferPointer { Data(buffer: $0) }
+        let buffer = try? ArrayBuffer.copy(data: data)
+        return VoiceInputResult(transcription: nil, audio: buffer)
+    }
+
     private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
         let listeningState = CPVoiceControlState(
             identifier: "listening",
@@ -218,12 +325,6 @@ class VoiceInputManager {
         }
         voiceControlTemplate = nil
     }
-
-    private func samplesAsData(_ samples: [Int16]) -> Data {
-        samples.withUnsafeBufferPointer { ptr in
-            Data(buffer: ptr)
-        }
-    }
 }
 
 enum VoiceInputError: Error {

package/lib/HybridAutoPlay.d.ts

@@ -0,0 +1,2 @@
+import type { AutoPlay } from './specs/AutoPlay.nitro';
+export declare const HybridAutoPlay: AutoPlay;

package/lib/HybridAutoPlay.js

@@ -0,0 +1,2 @@
+import { NitroModules } from 'react-native-nitro-modules';
+export const HybridAutoPlay = NitroModules.createHybridObject('AutoPlay');

package/lib/hooks/useIsAutoPlayFocused.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A hook to determine if the CarPlay/Android Auto screen is currently focused (visible).
+ *
+ * @param moduleName The name of the module to listen to.
+ * @returns `true` if the screen is focused, `false` otherwise.
+ */
+export declare function useIsAutoPlayFocused(moduleName: string): boolean;

package/lib/hooks/useIsAutoPlayFocused.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from 'react';
+import { HybridAutoPlay } from '..';
+/**
+ * A hook to determine if the CarPlay/Android Auto screen is currently focused (visible).
+ *
+ * @param moduleName The name of the module to listen to.
+ * @returns `true` if the screen is focused, `false` otherwise.
+ */
+export function useIsAutoPlayFocused(moduleName) {
+    const [isFocused, setIsFocused] = useState(false);
+    useEffect(() => {
+        const remove = HybridAutoPlay.addListenerRenderState(moduleName, (state) => {
+            setIsFocused(state === 'didAppear');
+        });
+        return () => {
+            remove();
+        };
+    }, [moduleName]);
+    return isFocused;
+}

package/lib/hybrid/HybridVoice.d.ts

@@ -0,0 +1,12 @@
+import type { VoiceInputOptions, VoiceInputResult } from '../types/Voice';
+type StartVoiceInput = {
+    (options: VoiceInputOptions & Required<Pick<VoiceInputOptions, 'onChunk'>>): Promise<void>;
+    (options?: Omit<VoiceInputOptions, 'onChunk'>): Promise<VoiceInputResult>;
+};
+export declare const HybridVoice: {
+    hasVoiceInputPermission: () => boolean;
+    requestVoiceInputPermission: () => Promise<boolean>;
+    startVoiceInput: StartVoiceInput;
+    stopVoiceInput: () => void;
+};
+export {};

package/lib/hybrid/HybridVoice.js

@@ -0,0 +1,13 @@
+import { NitroModules } from 'react-native-nitro-modules';
+const _native = NitroModules.createHybridObject('Voice');
+const startVoiceInput = (async (options) => {
+    const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText } = options ?? {};
+    const result = await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk);
+    return onChunk !== undefined ? undefined : result;
+});
+export const HybridVoice = {
+    hasVoiceInputPermission: () => _native.hasVoiceInputPermission(),
+    requestVoiceInputPermission: () => _native.requestVoiceInputPermission(),
+    startVoiceInput,
+    stopVoiceInput: () => _native.stopVoiceInput(),
+};

package/lib/hybrid.d.ts

@@ -0,0 +1,2 @@
+import type { AutoPlay as NitroAutoPlay } from './specs/AutoPlay.nitro';
+export declare const HybridAutoPlay: NitroAutoPlay;

package/lib/hybrid.js

@@ -0,0 +1,2 @@
+import { NitroModules } from 'react-native-nitro-modules';
+export const HybridAutoPlay = NitroModules.createHybridObject('AutoPlay');

package/lib/index.d.ts

@@ -1,7 +1,8 @@
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
+import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
-export { HybridAndroidAutoTelemetry, HybridAutoPlay };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
 export declare const HybridAndroidAutomotive: AndroidAutomotive | null;
 /**
  * These are the static module names for the app running on the mobile device, head unit screen and the CarPlay dashboard.
@@ -39,6 +40,7 @@ export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';
+export type { VoiceInputChunk, VoiceInputOptions, VoiceInputResult } from './types/Voice';
 export type { AlertPriority, NavigationAlert as Alert, NavigationAlertAction as AlertAction, } from './utils/NitroAlert';
 export type { ThemedColor } from './utils/NitroColor';
 export type { GridButton } from './utils/NitroGrid';

package/lib/index.js

@@ -3,8 +3,9 @@ import { NitroModules } from 'react-native-nitro-modules';
 import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
+import { HybridVoice } from './hybrid/HybridVoice';
 AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
-export { HybridAndroidAutoTelemetry, HybridAutoPlay };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
 export const HybridAndroidAutomotive = Platform.OS === 'android'
     ? NitroModules.createHybridObject('AndroidAutomotive')
     : null;

package/lib/specs/AutoPlay.nitro.d.ts

@@ -31,35 +31,6 @@ export interface AutoPlay extends HybridObject<{
      * @namespace Android
      */
     addListenerVoiceInput(callback: (coordinates: Location | undefined, query: string | undefined) => void): CleanupCallback;
-    /**
-     * Returns true if microphone permission has already been granted.
-     */
-    hasVoiceInputPermission(): boolean;
-    /**
-     * Request microphone permission from the user.
-     * On Android: uses the car context when Android Auto is connected, otherwise
-     * falls back to the React Native application context.
-     * On iOS: uses AVAudioApplication (iOS 17+) or AVAudioSession (iOS 15–16).
-     * Returns true if permission was granted, false if denied.
-     */
-    requestVoiceInputPermission(): Promise<boolean>;
-    /**
-     * Start an in-app voice recording session.
-     * On Android: acquires audio focus and captures via CarAudioRecord when
-     * Android Auto is connected, otherwise uses standard AudioRecord.
-     * On iOS: presents CPVoiceControlTemplate (when a car is connected) and
-     * captures audio via AVAudioEngine.
-     * Resolves with the complete raw PCM buffer (16 kHz, 16-bit, mono) when
-     * silence is detected, the max duration is reached, or stopVoiceInput() is called.
-     * Rejects if microphone permission has not been granted or recording fails to start.
-     */
-    startVoiceInput(silenceThresholdMs?: number, maxDurationMs?: number, listeningText?: string): Promise<ArrayBuffer>;
-    /**
-     * Stop the active voice recording session early. Causes the Promise returned
-     * by startVoiceInput() to resolve with the audio captured so far.
-     * No-op if no recording is in progress.
-     */
-    stopVoiceInput(): void;
     /**
      * sets the specified template as root template, initializes a new stack
      * Promise might contain an error message in case setting root template failed

package/lib/specs/AutomotivePermissionRequestTemplate.d.ts

@@ -0,0 +1,11 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroAutomotivePermissionRequestTemplateConfig } from '../templates/AutomotivePermissionRequestTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface AutomotivePermissionRequestTemplateConfig extends NitroTemplateConfig, NitroAutomotivePermissionRequestTemplateConfig {
+}
+export interface AutomotivePermissionRequestTemplate extends HybridObject<{
+    android: 'kotlin';
+}> {
+    createAutomotivePermissionRequestTemplate(config: AutomotivePermissionRequestTemplateConfig): void;
+}
+export {};

package/lib/specs/AutomotivePermissionRequestTemplate.js

@@ -0,0 +1 @@
+export {};

package/lib/specs/AutomotivePermissionRequestTemplate.nitro.d.ts

@@ -0,0 +1,11 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroAutomotivePermissionRequestTemplateConfig } from '../templates/AutomotivePermissionRequestTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface AutomotivePermissionRequestTemplateConfig extends NitroTemplateConfig, NitroAutomotivePermissionRequestTemplateConfig {
+}
+export interface AutomotivePermissionRequestTemplate extends HybridObject<{
+    android: 'kotlin';
+}> {
+    createAutomotivePermissionRequestTemplate(config: AutomotivePermissionRequestTemplateConfig): void;
+}
+export {};

package/lib/specs/AutomotivePermissionRequestTemplate.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/specs/Voice.nitro.d.ts

@@ -0,0 +1,51 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { VoiceInputChunk, VoiceInputResult } from '../types/Voice';
+export interface Voice extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    /**
+     * Returns true if all permissions required for voice input are granted.
+     * On iOS: checks both microphone and speech recognition authorization.
+     * On Android: checks RECORD_AUDIO permission.
+     */
+    hasVoiceInputPermission(): boolean;
+    /**
+     * Request all permissions required for voice input.
+     * On iOS: requests microphone permission then speech recognition authorization.
+     * On Android: requests RECORD_AUDIO via car context when connected, otherwise
+     * via the React Native application context.
+     * Returns true only if all required permissions were granted.
+     */
+    requestVoiceInputPermission(): Promise<boolean>;
+    /**
+     * Start an in-app voice session.
+     *
+     * When preferSpeechToText is true:
+     *   iOS — streams audio buffers into SFSpeechRecognizer during recording;
+     *          onChunk fires with partial transcription results; resolves with
+     *          { transcription } or falls back to { audio } if unavailable.
+     *   Android — checks SpeechRecognizer availability upfront; if available it
+     *              owns the mic and streams partial results via onChunk; if not
+     *              available falls back to PCM recording.
+     *
+     * When preferSpeechToText is false (default):
+     *   Both platforms record raw PCM; onChunk fires with audio chunks;
+     *   resolves with { audio }.
+     *
+     * @param silenceThresholdMs  ms of silence before auto-stop (default 1500)
+     * @param maxDurationMs       hard cap on recording duration (default 10000)
+     * @param listeningText       iOS only — text shown on CPVoiceControlTemplate
+     * @param preferSpeechToText  request STT transcription instead of raw PCM
+     * @param onChunk             optional streaming callback; when set the
+     *                            promise resolves with an empty VoiceInputResult
+     */
+    startVoiceInput(silenceThresholdMs?: number, maxDurationMs?: number, listeningText?: string, preferSpeechToText?: boolean, onChunk?: (chunk: VoiceInputChunk) => void): Promise<VoiceInputResult>;
+    /**
+     * Stop the active voice session early.
+     * For PCM mode: resolves startVoiceInput with audio captured so far.
+     * For STT mode: finalises the recognition request.
+     * No-op if no session is active.
+     */
+    stopVoiceInput(): void;
+}

package/lib/specs/Voice.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/templates/AutomotivePermissionRequestTemplate.d.ts

@@ -0,0 +1,23 @@
+import type { CustomActionButtonAndroid } from '../types/Button';
+import type { AutoText } from '../types/Text';
+import { type NitroAction } from '../utils/NitroAction';
+import { type HeaderActions, Template, type TemplateConfig } from './Template';
+export interface NitroAutomotivePermissionRequestTemplateConfig extends TemplateConfig {
+    headerActions?: Array<NitroAction>;
+    title: AutoText;
+    actions: Array<NitroAction>;
+}
+export type AutomotivePermissionRequestTemplateConfig = Omit<NitroAutomotivePermissionRequestTemplateConfig, 'headerActions' | 'buttons'> & {
+    /**
+     * action buttons, usually at the the top right on Android and a top bar on iOS
+     */
+    headerActions?: HeaderActions<AutomotivePermissionRequestTemplate>;
+    actions: [CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>] | [
+        CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>,
+        CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>
+    ];
+};
+export declare class AutomotivePermissionRequestTemplate extends Template<AutomotivePermissionRequestTemplateConfig, HeaderActions<AutomotivePermissionRequestTemplate>> {
+    private template;
+    constructor(config: AutomotivePermissionRequestTemplateConfig);
+}

package/lib/templates/AutomotivePermissionRequestTemplate.js

@@ -0,0 +1,18 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { NitroActionUtil } from '../utils/NitroAction';
+import { Template, } from './Template';
+const HybridAutomotivePermissionRequestTemplate = NitroModules.createHybridObject('AutomotivePermissionRequestTemplate');
+export class AutomotivePermissionRequestTemplate extends Template {
+    template = this;
+    constructor(config) {
+        super(config);
+        const { headerActions, actions, ...rest } = config;
+        const nitroConfig = {
+            ...rest,
+            id: this.id,
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
+            actions: NitroActionUtil.convert(this.template, actions),
+        };
+        HybridAutomotivePermissionRequestTemplate.createAutomotivePermissionRequestTemplate(nitroConfig);
+    }
+}