@iternio/react-native-auto-play 0.0.1

package/lib/hooks/useAndroidAutoTelemetry.d.ts

@@ -0,0 +1,35 @@
+import type { AndroidAutoPermissions, Telemetry } from '../types/Telemetry';
+interface Props {
+    /**
+     * Can be used to delay asking for permissions if set to false. True by default.
+     * Can be used to request other permissions first, so the permission request dialogs do not overlap.
+     * @default true
+     */
+    requestTelemetryPermissions?: boolean;
+    /**
+     * The permissions to check.
+     */
+    requiredPermissions: Array<AndroidAutoPermissions>;
+}
+/**
+ * Hook to check if the telemetry permissions are granted. If the permissions are not granted, it will request them from the user.
+ *
+ * @namespace Android
+ * @param requestTelemetryPermissions If true, the telemetry permissions will be requested from the user. Can be set to false initially, in case other permissions need to be requested first, so the permission request dialogs do not overlap.
+ * @param requiredPermissions The permissions to check.
+ */
+export declare const useAndroidAutoTelemetry: ({ requestTelemetryPermissions, requiredPermissions, }: Props) => {
+    /**
+     * True if the telemetry permissions are granted, false otherwise.
+     */
+    permissionsGranted: boolean;
+    /**
+     * The telemetry data.
+     */
+    telemetry: Telemetry | undefined;
+    /**
+     * The error message if the telemetry listener failed to start.
+     */
+    error: string | undefined;
+};
+export {};

package/lib/hooks/useAndroidAutoTelemetry.js

@@ -0,0 +1,74 @@
+import { useEffect, useState } from 'react';
+import { PermissionsAndroid } from 'react-native';
+import { HybridAndroidAutoTelemetry, HybridAutoPlay } from '..';
+/**
+ * Hook to check if the telemetry permissions are granted. If the permissions are not granted, it will request them from the user.
+ *
+ * @namespace Android
+ * @param requestTelemetryPermissions If true, the telemetry permissions will be requested from the user. Can be set to false initially, in case other permissions need to be requested first, so the permission request dialogs do not overlap.
+ * @param requiredPermissions The permissions to check.
+ */
+export const useAndroidAutoTelemetry = ({ requestTelemetryPermissions = true, requiredPermissions, }) => {
+    const [permissionsGranted, setPermissionsGranted] = useState(false);
+    const [telemetry, setTelemetry] = useState(undefined);
+    const [error, setError] = useState(undefined);
+    const [isConnected, setIsConnected] = useState(false);
+    useEffect(() => {
+        const removeDidConnect = HybridAutoPlay.addListener('didConnect', () => setIsConnected(true));
+        const removeDidDisconnect = HybridAutoPlay.addListener('didDisconnect', () => setIsConnected(false));
+        setIsConnected(HybridAutoPlay.isConnected());
+        return () => {
+            removeDidConnect();
+            removeDidDisconnect();
+        };
+    }, []);
+    useEffect(() => {
+        const checkPermissions = async () => {
+            const state = await Promise.all(requiredPermissions.map((permission) => PermissionsAndroid.check(permission).catch(() => false)));
+            setPermissionsGranted(state.every((granted) => granted));
+        };
+        checkPermissions();
+    }, [requiredPermissions]);
+    useEffect(() => {
+        if (!isConnected || !permissionsGranted) {
+            return;
+        }
+        const remove = HybridAndroidAutoTelemetry?.registerTelemetryListener((tlm, errorMessage) => {
+            setError(errorMessage);
+            setTelemetry(tlm);
+        });
+        return () => {
+            remove?.();
+        };
+    }, [isConnected, permissionsGranted]);
+    useEffect(() => {
+        if (requestTelemetryPermissions && requiredPermissions.length > 0) {
+            // PermissionsAndroid is not aware of automotive permissions
+            PermissionsAndroid.requestMultiple(requiredPermissions)
+                .then((value) => {
+                const isGranted = requiredPermissions.every((permission) => value[permission] === 'granted');
+                if (!isGranted) {
+                    console.warn('*** Android Auto telemetry permissions not granted');
+                    return;
+                }
+                setPermissionsGranted(true);
+            })
+                .catch((e) => console.error('*** Android Auto telemetry permissions error', e));
+        }
+        return;
+    }, [requestTelemetryPermissions, requiredPermissions]);
+    return {
+        /**
+         * True if the telemetry permissions are granted, false otherwise.
+         */
+        permissionsGranted,
+        /**
+         * The telemetry data.
+         */
+        telemetry,
+        /**
+         * The error message if the telemetry listener failed to start.
+         */
+        error,
+    };
+};

package/lib/hooks/useMapTemplate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * provides access to the map template
+ * obviously this works only on the map template component and its children
+ */
+export declare const useMapTemplate: () => import("..").MapTemplate | null;

package/lib/hooks/useMapTemplate.js

@@ -0,0 +1,9 @@
+import { useContext } from 'react';
+import { MapTemplateContext } from '../components/MapTemplateContext';
+/**
+ * provides access to the map template
+ * obviously this works only on the map template component and its children
+ */
+export const useMapTemplate = () => {
+    return useContext(MapTemplateContext);
+};

package/lib/hooks/useSafeAreaInsets.d.ts

@@ -0,0 +1 @@
+export declare const useSafeAreaInsets: () => import("..").SafeAreaInsets;

package/lib/hooks/useSafeAreaInsets.js

@@ -0,0 +1,5 @@
+import { useContext } from 'react';
+import { SafeAreaInsetsContext } from '../components/SafeAreaInsetsContext';
+export const useSafeAreaInsets = () => {
+    return useContext(SafeAreaInsetsContext);
+};

package/lib/index.d.ts

@@ -0,0 +1,37 @@
+import type { AndroidAutoTelemetry as NitroAndroidAutoTelemetry } from './specs/AndroidAutoTelemetry.nitro';
+import type { AutoPlay as NitroAutoPlay } from './specs/AutoPlay.nitro';
+export declare const HybridAutoPlay: NitroAutoPlay;
+export declare const HybridAndroidAutoTelemetry: NitroAndroidAutoTelemetry | null;
+/**
+ * These are the static module names for the app running on the mobile device, head unit screen and the CarPlay dashboard.
+ * Clusters generate uuids on native side that are passed in the RootComponentInitialProps
+ */
+export declare enum AutoPlayModules {
+    App = "main",
+    AutoPlayRoot = "AutoPlayRoot",
+    CarPlayDashboard = "CarPlayDashboard"
+}
+export * from './components/SafeAreaView';
+export * from './hooks/useAndroidAutoTelemetry';
+export * from './hooks/useMapTemplate';
+export * from './hooks/useSafeAreaInsets';
+export * from './scenes/AutoPlayCluster';
+export * from './scenes/CarPlayDashboardScene';
+export * from './templates/GridTemplate';
+export * from './templates/InformationTemplate';
+export * from './templates/ListTemplate';
+export * from './templates/MapTemplate';
+export * from './templates/MessageTemplate';
+export * from './templates/SearchTemplate';
+export * from './templates/Template';
+export * from './types/Button';
+export * from './types/Event';
+export * from './types/Image';
+export * from './types/Maneuver';
+export * from './types/RootComponent';
+export * from './types/Telemetry';
+export * from './types/Text';
+export * from './types/Trip';
+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

@@ -0,0 +1,39 @@
+import { Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
+AutoPlayHeadlessJsTask.registerHeadlessTask();
+export const HybridAutoPlay = NitroModules.createHybridObject('AutoPlay');
+export const HybridAndroidAutoTelemetry = Platform.OS === 'android'
+    ? NitroModules.createHybridObject('AndroidAutoTelemetry')
+    : null;
+/**
+ * These are the static module names for the app running on the mobile device, head unit screen and the CarPlay dashboard.
+ * Clusters generate uuids on native side that are passed in the RootComponentInitialProps
+ */
+export var AutoPlayModules;
+(function (AutoPlayModules) {
+    AutoPlayModules["App"] = "main";
+    AutoPlayModules["AutoPlayRoot"] = "AutoPlayRoot";
+    AutoPlayModules["CarPlayDashboard"] = "CarPlayDashboard";
+})(AutoPlayModules || (AutoPlayModules = {}));
+export * from './components/SafeAreaView';
+export * from './hooks/useAndroidAutoTelemetry';
+export * from './hooks/useMapTemplate';
+export * from './hooks/useSafeAreaInsets';
+export * from './scenes/AutoPlayCluster';
+export * from './scenes/CarPlayDashboardScene';
+export * from './templates/GridTemplate';
+export * from './templates/InformationTemplate';
+export * from './templates/ListTemplate';
+export * from './templates/MapTemplate';
+export * from './templates/MessageTemplate';
+export * from './templates/SearchTemplate';
+export * from './templates/Template';
+export * from './types/Button';
+export * from './types/Event';
+export * from './types/Image';
+export * from './types/Maneuver';
+export * from './types/RootComponent';
+export * from './types/Telemetry';
+export * from './types/Text';
+export * from './types/Trip';

package/lib/index.web.js

@@ -0,0 +1 @@
+"use strict";

package/lib/scenes/AutoPlayCluster.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { ZoomEvent } from '../specs/Cluster.nitro';
+import type { ColorScheme, RootComponentInitialProps } from '../types/RootComponent';
+import type { AutoAttributedString } from '../utils/NitroAttributedString';
+declare class Cluster {
+    private component;
+    private attributedInactiveDescriptionVariants;
+    /**
+     * Holds all cluster scene/session IDs and if they have a window/surface connected
+     */
+    private clusters;
+    constructor();
+    private registerComponent;
+    private applyAttributedInactiveDescriptionVariants;
+    setComponent(component: React.ComponentType<RootComponentInitialProps>): Promise<void>;
+    /**
+     * sets the text that is shown while no navigation is ongoing
+     * applies specified strings to all connected cluster of content type "Instruction Card"
+     * @namespace iOS
+     */
+    setAttributedInactiveDescriptionVariants(attributedInactiveDescriptionVariants: Array<AutoAttributedString>): void;
+    addListenerColorScheme(callback: (clusterId: string, payload: ColorScheme) => void): import("..").CleanupCallback;
+    /**
+     * add listener for cluster zoom buttons
+     * @namespace iOS
+     */
+    addListenerZoom(callback: (clusterId: string, payload: ZoomEvent) => void): import("..").CleanupCallback | undefined;
+    /**
+     * add listener for compass enable/disable
+     * @namespace iOS
+     */
+    addListenerCompass(callback: (clusterId: string, payload: boolean) => void): import("..").CleanupCallback | undefined;
+    /**
+     * add listener for speed limit enable/disable
+     * @namespace iOS
+     */
+    addListenerSpeedLimit(callback: (clusterId: string, payload: boolean) => void): import("..").CleanupCallback | undefined;
+}
+/**
+ * @namespace Android
+ * @namespace iOS >= 15.4
+ */
+export declare const AutoPlayCluster: Cluster;
+export {};

package/lib/scenes/AutoPlayCluster.js

@@ -0,0 +1,129 @@
+import React from 'react';
+import { AppRegistry, Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
+import { NitroImageUtil } from '../utils/NitroImage';
+const HybridCluster = NitroModules.createHybridObject('Cluster');
+class Cluster {
+    component = null;
+    attributedInactiveDescriptionVariants = [];
+    /**
+     * Holds all cluster scene/session IDs and if they have a window/surface connected
+     */
+    clusters = {};
+    constructor() {
+        HybridCluster.addListener('didConnect', (clusterId) => {
+            if (this.clusters[clusterId] != null) {
+                // in case didConnectWithWindow fires before didConnect
+                return;
+            }
+            this.clusters[clusterId] = false;
+            this.applyAttributedInactiveDescriptionVariants();
+        });
+        HybridCluster.addListener('didConnectWithWindow', (clusterId) => {
+            this.clusters[clusterId] = false;
+            this.registerComponent().catch((e) => {
+                console.error(e);
+            });
+        });
+        HybridCluster.addListener('didDisconnectFromWindow', (clusterId) => {
+            if (this.clusters[clusterId] == null) {
+                // in case didDisconnect fires before didDisconnectFromWindow
+                return;
+            }
+            this.clusters[clusterId] = false;
+        });
+        HybridCluster.addListener('didDisconnect', (clusterId) => {
+            delete this.clusters[clusterId];
+        });
+    }
+    async registerComponent() {
+        const { component } = this;
+        if (component == null) {
+            return;
+        }
+        const clusterIds = Object.entries(this.clusters)
+            .filter(([_, registered]) => !registered)
+            .map(([clusterId]) => clusterId);
+        for (const clusterId of clusterIds) {
+            AppRegistry.registerComponent(clusterId, () => (props) => React.createElement(SafeAreaInsetsProvider, {
+                moduleName: clusterId,
+                // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
+                children: React.createElement(component, props),
+            }));
+            this.clusters[clusterId] = true;
+            await HybridCluster.initRootView(clusterId);
+        }
+        this.applyAttributedInactiveDescriptionVariants();
+    }
+    applyAttributedInactiveDescriptionVariants() {
+        if (Platform.OS !== 'ios') {
+            return;
+        }
+        const variants = this.attributedInactiveDescriptionVariants.map((v) => ({
+            ...v,
+            images: v.images?.map((i) => ({ ...i, image: NitroImageUtil.convert(i.image) })),
+        }));
+        for (const clusterId of Object.keys(this.clusters)) {
+            HybridCluster.setAttributedInactiveDescriptionVariants(clusterId, variants);
+        }
+    }
+    setComponent(component) {
+        if (this.component != null) {
+            throw new Error('ClusterScene.setComponent can be called once only');
+        }
+        this.component = component;
+        return this.registerComponent();
+    }
+    /**
+     * sets the text that is shown while no navigation is ongoing
+     * applies specified strings to all connected cluster of content type "Instruction Card"
+     * @namespace iOS
+     */
+    setAttributedInactiveDescriptionVariants(attributedInactiveDescriptionVariants) {
+        if (Platform.OS !== 'ios') {
+            console.warn(`ClusterScene.setAttributedInactiveDescriptionVariants not supported for ${Platform.OS}`);
+            return;
+        }
+        this.attributedInactiveDescriptionVariants = attributedInactiveDescriptionVariants;
+        this.applyAttributedInactiveDescriptionVariants();
+    }
+    addListenerColorScheme(callback) {
+        return HybridCluster.addListenerColorScheme(callback);
+    }
+    /**
+     * add listener for cluster zoom buttons
+     * @namespace iOS
+     */
+    addListenerZoom(callback) {
+        if (Platform.OS !== 'ios') {
+            return;
+        }
+        return HybridCluster.addListenerZoom(callback);
+    }
+    /**
+     * add listener for compass enable/disable
+     * @namespace iOS
+     */
+    addListenerCompass(callback) {
+        if (Platform.OS !== 'ios') {
+            return;
+        }
+        return HybridCluster.addListenerCompass(callback);
+    }
+    /**
+     * add listener for speed limit enable/disable
+     * @namespace iOS
+     */
+    addListenerSpeedLimit(callback) {
+        if (Platform.OS !== 'ios') {
+            return;
+        }
+        return HybridCluster.addListenerSpeedLimit(callback);
+    }
+}
+/**
+ * @namespace Android
+ * @namespace iOS >= 15.4
+ */
+export const AutoPlayCluster = new Cluster();

package/lib/scenes/CarPlayDashboardScene.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+import type { BaseCarPlayDashboardButton } from '../specs/CarPlayDashboard.nitro';
+import type { EventName, VisibilityState } from '../types/Event';
+import type { AutoImage } from '../types/Image';
+import type { ColorScheme, RootComponentInitialProps } from '../types/RootComponent';
+export interface CarPlayDashboardButton extends BaseCarPlayDashboardButton {
+    image: AutoImage;
+}
+export type CarPlayDashboardEvent = EventName | VisibilityState;
+declare class Dashboard {
+    private component;
+    isConnected: boolean;
+    readonly id = "CarPlayDashboard";
+    constructor();
+    private setIsConnected;
+    private registerComponent;
+    setComponent(component: React.ComponentType<RootComponentInitialProps>): void;
+    /**
+     * sets the dashboard shortcut buttons, make sure to supply at least one button as soon as possible,
+     * otherwise the dashboard will not show up!
+     * @namespace iOS
+     */
+    setButtons(buttons: Array<CarPlayDashboardButton>): void;
+    /**
+     * attach a listener for generic notifications like didConnect, didDisconnect, ...
+     * @namespace iOS
+     * @param eventType generic events
+     * @returns callback to remove the listener
+     */
+    addListener(event: EventName, callback: () => void): import("..").CleanupCallback;
+    addListenerRenderState(callback: (payload: VisibilityState) => void): import("..").CleanupCallback;
+    addListenerColorScheme(callback: (payload: ColorScheme) => void): import("..").CleanupCallback;
+}
+export declare const CarPlayDashboard: Dashboard;
+export {};

package/lib/scenes/CarPlayDashboardScene.js

@@ -0,0 +1,88 @@
+import React from 'react';
+import { AppRegistry, Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import { HybridAutoPlay } from '..';
+import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
+import { NitroImageUtil } from '../utils/NitroImage';
+const HybridCarPlayDashboard = Platform.OS === 'ios'
+    ? NitroModules.createHybridObject('CarPlayDashboard')
+    : null;
+class Dashboard {
+    component = null;
+    isConnected = false;
+    id = 'CarPlayDashboard';
+    constructor() {
+        if (HybridCarPlayDashboard == null) {
+            return;
+        }
+        HybridCarPlayDashboard.addListener('didConnect', () => this.setIsConnected(true));
+        HybridCarPlayDashboard.addListener('didDisconnect', () => this.setIsConnected(false));
+    }
+    setIsConnected(isConnected) {
+        this.isConnected = isConnected;
+        this.registerComponent();
+    }
+    registerComponent() {
+        if (HybridCarPlayDashboard == null) {
+            return;
+        }
+        const { component, isConnected } = this;
+        if (!isConnected || component == null) {
+            return;
+        }
+        AppRegistry.registerComponent(this.id, () => (props) => React.createElement(SafeAreaInsetsProvider, {
+            moduleName: this.id,
+            // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
+            children: React.createElement(component, props),
+        }));
+        HybridCarPlayDashboard.initRootView();
+    }
+    setComponent(component) {
+        if (Platform.OS !== 'ios') {
+            console.warn(`CarPlayDashboard.setComponent is not supported on ${Platform.OS}`);
+            return;
+        }
+        if (this.component != null) {
+            throw new Error('CarPlayDashboard.setComponent can be called once only');
+        }
+        this.component = component;
+        this.registerComponent();
+    }
+    /**
+     * sets the dashboard shortcut buttons, make sure to supply at least one button as soon as possible,
+     * otherwise the dashboard will not show up!
+     * @namespace iOS
+     */
+    setButtons(buttons) {
+        if (HybridCarPlayDashboard == null) {
+            console.warn(`CarPlayDashboard.setButtons is not supported on ${Platform.OS}`);
+            return;
+        }
+        HybridCarPlayDashboard.setButtons(buttons.map((button) => ({ ...button, image: NitroImageUtil.convert(button.image) })));
+    }
+    /**
+     * attach a listener for generic notifications like didConnect, didDisconnect, ...
+     * @namespace iOS
+     * @param eventType generic events
+     * @returns callback to remove the listener
+     */
+    addListener(event, callback) {
+        if (HybridCarPlayDashboard == null) {
+            throw new Error(`CarPlayDashboard.addListener is not supported on ${Platform.OS}`);
+        }
+        return HybridCarPlayDashboard.addListener(event, callback);
+    }
+    addListenerRenderState(callback) {
+        if (HybridCarPlayDashboard == null) {
+            throw new Error(`CarPlayDashboard.addListener is not supported on ${Platform.OS}`);
+        }
+        return HybridAutoPlay.addListenerRenderState(this.id, callback);
+    }
+    addListenerColorScheme(callback) {
+        if (HybridCarPlayDashboard == null) {
+            throw new Error(`CarPlayDashboard.addListener is not supported on ${Platform.OS}`);
+        }
+        return HybridCarPlayDashboard.addListenerColorScheme(callback);
+    }
+}
+export const CarPlayDashboard = new Dashboard();

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

@@ -0,0 +1,15 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { CleanupCallback } from '../types/Event';
+import type { Telemetry } from '../types/Telemetry';
+export interface AndroidAutoTelemetry extends HybridObject<{
+    android: 'kotlin';
+}> {
+    /**
+     * Register a listener for Android Auto telemetry data. Should be registered only after the telemetry permissions are granted otherwise no data will be received.
+     * @param callback the callback to receive the telemetry data
+     * @param error the error message if the telemetry listener failed to start
+     * @returns callback to remove the listener
+     * @namespace Android
+     */
+    registerTelemetryListener(callback: (tlm?: Telemetry, error?: string) => void): CleanupCallback;
+}

package/lib/specs/AndroidAutoTelemetry.nitro.js

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

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

@@ -0,0 +1,64 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { TemplateConfig } from '../templates/Template';
+import type { CleanupCallback, EventName, SafeAreaInsets, VisibilityState } from '../types/Event';
+import type { NitroAction } from '../utils/NitroAction';
+export interface NitroTemplateConfig extends TemplateConfig {
+    id: string;
+}
+export interface AutoPlay extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    /**
+     * attach a listener for didConnect and didDisconnect
+     * @namespace all
+     * @param eventType generic events
+     * @returns callback to remove the listener
+     */
+    addListener(eventType: EventName, callback: () => void): CleanupCallback;
+    /**
+     * adds a listener for the session/scene state
+     * fires willAppear & didAppear when the scene/session is visible
+     * fires willDisappear & didDisappear when the scene/session is not visible
+     * @param moduleName on of @AutoPlayModules, a cluster scene uuid or your main for the WindowApplicationSceneDelegate
+     */
+    addListenerRenderState(moduleName: string, callback: (payload: VisibilityState) => void): CleanupCallback;
+    /**
+     * sets the specified template as root template, initializes a new stack
+     * Promise might contain an error message in case setting root template failed
+     * can be used on any Android screen/iOS scene
+     */
+    setRootTemplate(templateId: string): Promise<void>;
+    /**
+     * push a template to the AutoPlayRoot Android screen/iOS scene
+     */
+    pushTemplate(templateId: string): Promise<void>;
+    /**
+     * remove the top template from the stack
+     * @param animate - defaults to true
+     */
+    popTemplate(animate?: boolean): Promise<void>;
+    /**
+     * remove all templates from the stack except the root template
+     * @param animate - defaults to true
+     */
+    popToRootTemplate(animate?: boolean): Promise<void>;
+    /**
+     * removes all templates until the specified one is the top template
+     */
+    popToTemplate(templateId: string, animate?: boolean): Promise<void>;
+    /**
+     * callback for safe area insets changes
+     * @param insets the insets that you use to determine the safe area for this view.
+     */
+    addSafeAreaInsetsListener(moduleName: string, callback: (insets: SafeAreaInsets) => void): CleanupCallback;
+    /**
+     * update a templates headerActions
+     */
+    setTemplateHeaderActions(templateId: string, headerActions?: Array<NitroAction>): void;
+    /**
+     * Check if AutoPlay is connected.
+     * @returns true if AutoPlay is connected, false otherwise.
+     */
+    isConnected(): boolean;
+}

package/lib/specs/AutoPlay.nitro.js

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

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

@@ -0,0 +1,22 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { CleanupCallback, EventName } from '../types/Event';
+import type { ColorScheme } from '../types/RootComponent';
+import type { NitroImage } from '../utils/NitroImage';
+export interface BaseCarPlayDashboardButton {
+    titleVariants: Array<string>;
+    subtitleVariants: Array<string>;
+    onPress: () => void;
+    launchHeadUnitScene?: boolean;
+}
+interface NitroCarPlayDashboardButton extends BaseCarPlayDashboardButton {
+    image: NitroImage;
+}
+export interface CarPlayDashboard extends HybridObject<{
+    ios: 'swift';
+}> {
+    addListener(eventType: EventName, callback: () => void): CleanupCallback;
+    setButtons(buttons: Array<NitroCarPlayDashboardButton>): Promise<void>;
+    initRootView(): void;
+    addListenerColorScheme(callback: (payload: ColorScheme) => void): CleanupCallback;
+}
+export {};

package/lib/specs/CarPlayDashboard.nitro.js

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

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

@@ -0,0 +1,19 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { CleanupCallback } from '../types/Event';
+import type { ColorScheme } from '../types/RootComponent';
+import type { NitroAttributedString } from '../utils/NitroAttributedString';
+type ClusterEventName = 'didConnect' | 'didConnectWithWindow' | 'didDisconnect' | 'didDisconnectFromWindow';
+export type ZoomEvent = 'in' | 'out';
+export interface Cluster extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    addListener(eventType: ClusterEventName, callback: (clusterId: string) => void): CleanupCallback;
+    initRootView(clusterId: string): Promise<void>;
+    setAttributedInactiveDescriptionVariants(clusterId: string, attributedInactiveDescriptionVariants: Array<NitroAttributedString>): void;
+    addListenerColorScheme(callback: (clusterId: string, payload: ColorScheme) => void): CleanupCallback;
+    addListenerZoom(callback: (clusterId: string, payload: ZoomEvent) => void): CleanupCallback;
+    addListenerCompass(callback: (clusterId: string, payload: boolean) => void): CleanupCallback;
+    addListenerSpeedLimit(callback: (clusterId: string, payload: boolean) => void): CleanupCallback;
+}
+export {};

package/lib/specs/Cluster.nitro.js

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